From 79ab46f2bfc4d9fe87118adfc32f2f3c4543153e Mon Sep 17 00:00:00 2001 From: Aleksey Plekhanov Date: Fri, 18 Mar 2022 17:54:49 +0300 Subject: [PATCH] IGNITE-16710 Add generated parser sources to git --- modules/calcite/pom.xml | 2 +- modules/calcite/src/main/codegen/config.fmpp | 3 +- .../query/calcite/CalciteQueryProcessor.java | 2 +- .../calcite/sql/IgniteSqlAlterTable.java | 2 +- .../sql/IgniteSqlAlterTableAddColumn.java | 2 +- .../sql/IgniteSqlAlterTableDropColumn.java | 2 +- .../query/calcite/sql/IgniteSqlAlterUser.java | 2 +- .../calcite/sql/IgniteSqlCreateIndex.java | 2 +- .../calcite/sql/IgniteSqlCreateTable.java | 2 +- .../calcite/sql/IgniteSqlCreateUser.java | 2 +- .../query/calcite/sql/IgniteSqlDropIndex.java | 2 +- .../query/calcite/sql/IgniteSqlDropUser.java | 2 +- .../sql/generated/IgniteSqlParserImpl.java | 33498 ++++++++++++++++ .../IgniteSqlParserImplConstants.java | 1584 + .../IgniteSqlParserImplTokenManager.java | 26455 ++++++++++++ .../calcite/sql/generated/ParseException.java | 192 + .../sql/generated/SimpleCharStream.java | 439 + .../query/calcite/sql/generated/Token.java | 81 + .../calcite/sql/generated/TokenMgrError.java | 133 + .../calcite/sql/generated/package-info.java | 28 + .../calcite/sql/SqlCustomParserTest.java | 1 + parent/pom.xml | 1 + 22 files changed, 62425 insertions(+), 12 deletions(-) create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImpl.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplConstants.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplTokenManager.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/ParseException.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/SimpleCharStream.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/Token.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/TokenMgrError.java create mode 100644 modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/package-info.java diff --git a/modules/calcite/pom.xml b/modules/calcite/pom.xml index 600be822b4add..dcb39b03bca3f 100644 --- a/modules/calcite/pom.xml +++ b/modules/calcite/pom.xml @@ -297,7 +297,7 @@ ${project.build.directory}/generated-sources/fmpp - ${project.build.directory}/generated-sources/javacc + ${project.build.sourceDirectory} **/Parser.jj diff --git a/modules/calcite/src/main/codegen/config.fmpp b/modules/calcite/src/main/codegen/config.fmpp index aeaa0b635cd75..f692ad75916a8 100644 --- a/modules/calcite/src/main/codegen/config.fmpp +++ b/modules/calcite/src/main/codegen/config.fmpp @@ -21,7 +21,7 @@ data: { # FMPP will use the declaration from default_config.fmpp. parser: { # Generated parser implementation class package and name - package: "org.apache.ignite.internal.processors.query.calcite.sql", + package: "org.apache.ignite.internal.processors.query.calcite.sql.generated", class: "IgniteSqlParserImpl", # List of additional classes and packages to import. @@ -35,6 +35,7 @@ data: { "org.apache.ignite.internal.processors.query.calcite.util.IgniteResource", "org.apache.ignite.lang.IgniteUuid", "org.apache.calcite.sql.ddl.SqlDdlNodes", + "org.apache.ignite.internal.processors.query.calcite.sql.*", ] # List of new keywords. Example: "DATABASES", "TABLES". If the keyword is diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/CalciteQueryProcessor.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/CalciteQueryProcessor.java index 347bfd2d2eabb..beb383638c613 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/CalciteQueryProcessor.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/CalciteQueryProcessor.java @@ -77,9 +77,9 @@ import org.apache.ignite.internal.processors.query.calcite.schema.SchemaHolder; import org.apache.ignite.internal.processors.query.calcite.schema.SchemaHolderImpl; import org.apache.ignite.internal.processors.query.calcite.sql.IgniteSqlConformance; -import org.apache.ignite.internal.processors.query.calcite.sql.IgniteSqlParserImpl; import org.apache.ignite.internal.processors.query.calcite.sql.fun.IgniteOwnSqlOperatorTable; import org.apache.ignite.internal.processors.query.calcite.sql.fun.IgniteStdSqlOperatorTable; +import org.apache.ignite.internal.processors.query.calcite.sql.generated.IgniteSqlParserImpl; import org.apache.ignite.internal.processors.query.calcite.trait.CorrelationTraitDef; import org.apache.ignite.internal.processors.query.calcite.trait.DistributionTraitDef; import org.apache.ignite.internal.processors.query.calcite.trait.RewindabilityTraitDef; diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTable.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTable.java index 67e70312a9edf..d7f0453ad0869 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTable.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTable.java @@ -31,7 +31,7 @@ public class IgniteSqlAlterTable extends IgniteAbstractSqlAlterTable { private final boolean logging; /** */ - protected IgniteSqlAlterTable(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, boolean logging) { + public IgniteSqlAlterTable(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, boolean logging) { super(pos, ifExists, tblName); this.logging = logging; } diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableAddColumn.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableAddColumn.java index 0687bbb91e8fc..5f78ef112410e 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableAddColumn.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableAddColumn.java @@ -36,7 +36,7 @@ public class IgniteSqlAlterTableAddColumn extends IgniteAbstractSqlAlterTable { private final SqlNodeList columns; /** */ - protected IgniteSqlAlterTableAddColumn(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, + public IgniteSqlAlterTableAddColumn(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, boolean ifNotExistsColumn, SqlNodeList columns) { super(pos, ifExists, tblName); this.ifNotExistsColumn = ifNotExistsColumn; diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableDropColumn.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableDropColumn.java index e7a1b7e9d59f1..dedb5fee9079c 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableDropColumn.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterTableDropColumn.java @@ -36,7 +36,7 @@ public class IgniteSqlAlterTableDropColumn extends IgniteAbstractSqlAlterTable { private final SqlNodeList columns; /** */ - protected IgniteSqlAlterTableDropColumn(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, + public IgniteSqlAlterTableDropColumn(SqlParserPos pos, boolean ifExists, SqlIdentifier tblName, boolean ifExistsColumn, SqlNodeList columns) { super(pos, ifExists, tblName); this.ifExistsColumn = ifExistsColumn; diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterUser.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterUser.java index 47720856ba24b..4dbcc28843aa0 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterUser.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlAlterUser.java @@ -44,7 +44,7 @@ public class IgniteSqlAlterUser extends SqlDdl { new SqlSpecialOperator("ALTER USER", SqlKind.OTHER_DDL); /** */ - protected IgniteSqlAlterUser(SqlParserPos pos, SqlIdentifier user, SqlLiteral pwd) { + public IgniteSqlAlterUser(SqlParserPos pos, SqlIdentifier user, SqlLiteral pwd) { super(OPERATOR, pos); this.user = Objects.requireNonNull(user, "user"); this.pwd = Objects.requireNonNull(pwd, "password"); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateIndex.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateIndex.java index ca472d06b9e3a..45a847363abfd 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateIndex.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateIndex.java @@ -55,7 +55,7 @@ public class IgniteSqlCreateIndex extends SqlCreate { new SqlSpecialOperator("CREATE INDEX", SqlKind.CREATE_INDEX); /** Creates a SqlCreateIndex. */ - protected IgniteSqlCreateIndex(SqlParserPos pos, boolean ifNotExists, SqlIdentifier idxName, SqlIdentifier tblName, + public IgniteSqlCreateIndex(SqlParserPos pos, boolean ifNotExists, SqlIdentifier idxName, SqlIdentifier tblName, SqlNodeList columnList, SqlNumericLiteral parallel, SqlNumericLiteral inlineSize) { super(OPERATOR, pos, false, ifNotExists); this.idxName = Objects.requireNonNull(idxName, "index name"); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateTable.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateTable.java index bda05e6c745be..f00b1cabfdbca 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateTable.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateTable.java @@ -51,7 +51,7 @@ public class IgniteSqlCreateTable extends SqlCreate { new SqlSpecialOperator("CREATE TABLE", SqlKind.CREATE_TABLE); /** Creates a SqlCreateTable. */ - protected IgniteSqlCreateTable(SqlParserPos pos, boolean ifNotExists, SqlIdentifier name, + public IgniteSqlCreateTable(SqlParserPos pos, boolean ifNotExists, SqlIdentifier name, @Nullable SqlNodeList columnList, @Nullable SqlNode qry, @Nullable SqlNodeList createOptionList) { super(OPERATOR, pos, false, ifNotExists); this.name = Objects.requireNonNull(name, "name"); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateUser.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateUser.java index 5074080e228c5..c93add280c4bc 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateUser.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlCreateUser.java @@ -44,7 +44,7 @@ public class IgniteSqlCreateUser extends SqlCreate { new SqlSpecialOperator("CREATE USER", SqlKind.OTHER_DDL); /** */ - protected IgniteSqlCreateUser(SqlParserPos pos, SqlIdentifier user, SqlLiteral pwd) { + public IgniteSqlCreateUser(SqlParserPos pos, SqlIdentifier user, SqlLiteral pwd) { super(OPERATOR, pos, false, false); this.user = Objects.requireNonNull(user, "user"); this.pwd = Objects.requireNonNull(pwd, "password"); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropIndex.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropIndex.java index 57afc9ca0c3ca..793f3a65ad2aa 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropIndex.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropIndex.java @@ -40,7 +40,7 @@ public class IgniteSqlDropIndex extends SqlDrop { new SqlSpecialOperator("DROP INDEX", SqlKind.DROP_INDEX); /** */ - protected IgniteSqlDropIndex(SqlParserPos pos, boolean ifExists, SqlIdentifier idxName) { + public IgniteSqlDropIndex(SqlParserPos pos, boolean ifExists, SqlIdentifier idxName) { super(OPERATOR, pos, ifExists); name = Objects.requireNonNull(idxName, "index name"); } diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropUser.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropUser.java index bd067f0e7dc1b..081737fb8b338 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropUser.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/IgniteSqlDropUser.java @@ -40,7 +40,7 @@ public class IgniteSqlDropUser extends SqlDrop { new SqlSpecialOperator("DROP USER", SqlKind.OTHER_DDL); /** */ - protected IgniteSqlDropUser(SqlParserPos pos, SqlIdentifier user) { + public IgniteSqlDropUser(SqlParserPos pos, SqlIdentifier user) { super(OPERATOR, pos, false); this.user = Objects.requireNonNull(user, "user"); } diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImpl.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImpl.java new file mode 100644 index 0000000000000..505da8f81115a --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImpl.java @@ -0,0 +1,33498 @@ +/* Generated By:JavaCC: Do not edit this line. IgniteSqlParserImpl.java */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +import java.util.UUID; +import org.apache.calcite.sql.SqlCreate; +import org.apache.calcite.sql.SqlDrop; +import org.apache.calcite.sql.SqlLiteral; +import org.apache.calcite.schema.ColumnStrategy; +import org.apache.ignite.internal.processors.query.calcite.util.IgniteResource; +import org.apache.ignite.lang.IgniteUuid; +import org.apache.calcite.sql.ddl.SqlDdlNodes; +import org.apache.ignite.internal.processors.query.calcite.sql.*; + +import org.apache.calcite.avatica.util.Casing; +import org.apache.calcite.avatica.util.DateTimeUtils; +import org.apache.calcite.avatica.util.TimeUnit; +import org.apache.calcite.rel.type.RelDataType; +import org.apache.calcite.runtime.CalciteContextException; +import org.apache.calcite.sql.JoinConditionType; +import org.apache.calcite.sql.JoinType; +import org.apache.calcite.sql.SqlAlter; +import org.apache.calcite.sql.SqlBasicTypeNameSpec; +import org.apache.calcite.sql.SqlBinaryOperator; +import org.apache.calcite.sql.SqlCall; +import org.apache.calcite.sql.SqlCharStringLiteral; +import org.apache.calcite.sql.SqlCollation; +import org.apache.calcite.sql.SqlCollectionTypeNameSpec; +import org.apache.calcite.sql.SqlDataTypeSpec; +import org.apache.calcite.sql.SqlDateLiteral; +import org.apache.calcite.sql.SqlDelete; +import org.apache.calcite.sql.SqlDescribeSchema; +import org.apache.calcite.sql.SqlDescribeTable; +import org.apache.calcite.sql.SqlDynamicParam; +import org.apache.calcite.sql.SqlExplain; +import org.apache.calcite.sql.SqlExplainFormat; +import org.apache.calcite.sql.SqlExplainLevel; +import org.apache.calcite.sql.SqlFunction; +import org.apache.calcite.sql.SqlFunctionCategory; +import org.apache.calcite.sql.SqlHint; +import org.apache.calcite.sql.SqlIdentifier; +import org.apache.calcite.sql.SqlInsert; +import org.apache.calcite.sql.SqlInsertKeyword; +import org.apache.calcite.sql.SqlIntervalLiteral; +import org.apache.calcite.sql.SqlIntervalQualifier; +import org.apache.calcite.sql.SqlJdbcDataTypeName; +import org.apache.calcite.sql.SqlJdbcFunctionCall; +import org.apache.calcite.sql.SqlJoin; +import org.apache.calcite.sql.SqlJsonConstructorNullClause; +import org.apache.calcite.sql.SqlJsonEncoding; +import org.apache.calcite.sql.SqlJsonExistsErrorBehavior; +import org.apache.calcite.sql.SqlJsonEmptyOrError; +import org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior; +import org.apache.calcite.sql.SqlJsonQueryWrapperBehavior; +import org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior; +import org.apache.calcite.sql.SqlJsonValueReturning; +import org.apache.calcite.sql.SqlKind; +import org.apache.calcite.sql.SqlLiteral; +import org.apache.calcite.sql.SqlMatchRecognize; +import org.apache.calcite.sql.SqlMerge; +import org.apache.calcite.sql.SqlNode; +import org.apache.calcite.sql.SqlNodeList; +import org.apache.calcite.sql.SqlNumericLiteral; +import org.apache.calcite.sql.SqlOperator; +import org.apache.calcite.sql.SqlOrderBy; +import org.apache.calcite.sql.SqlPivot; +import org.apache.calcite.sql.SqlPostfixOperator; +import org.apache.calcite.sql.SqlPrefixOperator; +import org.apache.calcite.sql.SqlRowTypeNameSpec; +import org.apache.calcite.sql.SqlSampleSpec; +import org.apache.calcite.sql.SqlSelect; +import org.apache.calcite.sql.SqlSelectKeyword; +import org.apache.calcite.sql.SqlSetOption; +import org.apache.calcite.sql.SqlSnapshot; +import org.apache.calcite.sql.SqlTableRef; +import org.apache.calcite.sql.SqlTimeLiteral; +import org.apache.calcite.sql.SqlTimestampLiteral; +import org.apache.calcite.sql.SqlTypeNameSpec; +import org.apache.calcite.sql.SqlUnnestOperator; +import org.apache.calcite.sql.SqlUnpivot; +import org.apache.calcite.sql.SqlUpdate; +import org.apache.calcite.sql.SqlUserDefinedTypeNameSpec; +import org.apache.calcite.sql.SqlUtil; +import org.apache.calcite.sql.SqlWindow; +import org.apache.calcite.sql.SqlWith; +import org.apache.calcite.sql.SqlWithItem; +import org.apache.calcite.sql.fun.SqlCase; +import org.apache.calcite.sql.fun.SqlInternalOperators; +import org.apache.calcite.sql.fun.SqlLibraryOperators; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; +import org.apache.calcite.sql.fun.SqlTrimFunction; +import org.apache.calcite.sql.parser.Span; +import org.apache.calcite.sql.parser.SqlAbstractParserImpl; +import org.apache.calcite.sql.parser.SqlParseException; +import org.apache.calcite.sql.parser.SqlParser; +import org.apache.calcite.sql.parser.SqlParserImplFactory; +import org.apache.calcite.sql.parser.SqlParserPos; +import org.apache.calcite.sql.parser.SqlParserUtil; +import org.apache.calcite.sql.type.SqlTypeName; +import org.apache.calcite.sql.validate.SqlConformance; +import org.apache.calcite.util.Glossary; +import org.apache.calcite.util.NlsString; +import org.apache.calcite.util.Pair; +import org.apache.calcite.util.SourceStringReader; +import org.apache.calcite.util.Util; +import org.apache.calcite.util.trace.CalciteTrace; + +import org.slf4j.Logger; + +import java.io.Reader; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +import static org.apache.calcite.util.Static.RESOURCE; + +/** + * SQL parser, generated from Parser.jj by JavaCC. + * + *

The public wrapper for this parser is {@link SqlParser}. + */ +public class IgniteSqlParserImpl extends SqlAbstractParserImpl implements IgniteSqlParserImplConstants { + private static final Logger LOGGER = CalciteTrace.getParserTracer(); + + // Can't use quoted literal because of a bug in how JavaCC translates + // backslash-backslash. + private static final char BACKSLASH = 0x5c; + private static final char DOUBLE_QUOTE = 0x22; + private static final String DQ = DOUBLE_QUOTE + ""; + private static final String DQDQ = DQ + DQ; + + private static Metadata metadata; + + private Casing unquotedCasing; + private Casing quotedCasing; + private int identifierMaxLength; + private SqlConformance conformance; + + /** + * {@link SqlParserImplFactory} implementation for creating parser. + */ + public static final SqlParserImplFactory FACTORY = new SqlParserImplFactory() { + public SqlAbstractParserImpl getParser(Reader reader) { + final IgniteSqlParserImpl parser = new IgniteSqlParserImpl(reader); + if (reader instanceof SourceStringReader) { + final String sql = + ((SourceStringReader) reader).getSourceString(); + parser.setOriginalSql(sql); + } + return parser; + } + }; + + public SqlParseException normalizeException(Throwable ex) { + try { + if (ex instanceof ParseException) { + ex = cleanupParseException((ParseException) ex); + } + return convertException(ex); + } catch (ParseException e) { + throw new AssertionError(e); + } + } + + public Metadata getMetadata() { + synchronized (IgniteSqlParserImpl.class) { + if (metadata == null) { + metadata = new MetadataImpl( + new IgniteSqlParserImpl(new java.io.StringReader(""))); + } + return metadata; + } + } + + public void setTabSize(int tabSize) { + jj_input_stream.setTabSize(tabSize); + } + + public void switchTo(SqlAbstractParserImpl.LexicalState state) { + final int stateOrdinal = + Arrays.asList(IgniteSqlParserImplTokenManager.lexStateNames) + .indexOf(state.name()); + token_source.SwitchTo(stateOrdinal); + } + + public void setQuotedCasing(Casing quotedCasing) { + this.quotedCasing = quotedCasing; + } + + public void setUnquotedCasing(Casing unquotedCasing) { + this.unquotedCasing = unquotedCasing; + } + + public void setIdentifierMaxLength(int identifierMaxLength) { + this.identifierMaxLength = identifierMaxLength; + } + + public void setConformance(SqlConformance conformance) { + this.conformance = conformance; + } + + public SqlNode parseSqlExpressionEof() throws Exception { + return SqlExpressionEof(); + } + + public SqlNode parseSqlStmtEof() throws Exception { + return SqlStmtEof(); + } + + public SqlNodeList parseSqlStmtList() throws Exception { + return SqlStmtList(); + } + + private SqlNode extend(SqlNode table, SqlNodeList extendList) { + return SqlStdOperatorTable.EXTEND.createCall( + Span.of(table, extendList).pos(), table, extendList); + } + + /** Adds a warning that a token such as "HOURS" was used, + * whereas the SQL standard only allows "HOUR". + * + *

Currently, we silently add an exception to a list of warnings. In + * future, we may have better compliance checking, for example a strict + * compliance mode that throws if any non-standard features are used. */ + private TimeUnit warn(TimeUnit timeUnit) throws ParseException { + final String token = getToken(0).image.toUpperCase(Locale.ROOT); + warnings.add( + SqlUtil.newContextException(getPos(), + RESOURCE.nonStandardFeatureUsed(token))); + return timeUnit; + } + + void debug_message1() throws ParseException { + LOGGER.info("{} , {}", getToken(0).image, getToken(1).image); + } + + String unquotedIdentifier() throws ParseException { + return SqlParserUtil.toCase(getToken(0).image, unquotedCasing); + } + +/** + * Allows parser to be extended with new types of table references. The + * default implementation of this production is empty. + */ + final public SqlNode ExtendedTableRef() throws ParseException { + UnusedExtension(); + {if (true) return null;} + throw new Error("Missing return statement in function"); + } + +/** + * Allows an OVER clause following a table expression as an extension to + * standard SQL syntax. The default implementation of this production is empty. + */ + final public SqlNode TableOverOpt() throws ParseException { + {if (true) return null;} + throw new Error("Missing return statement in function"); + } + +/* + * Parses dialect-specific keywords immediately following the SELECT keyword. + */ + final public void SqlSelectKeywords(List keywords) throws ParseException { + E(); + } + +/* + * Parses dialect-specific keywords immediately following the INSERT keyword. + */ + final public void SqlInsertKeywords(List keywords) throws ParseException { + E(); + } + +/* +* Parse Floor/Ceil function parameters +*/ + final public SqlNode FloorCeilOptions(Span s, boolean floorFlag) throws ParseException { + SqlNode node; + node = StandardFloorCeilOptions(s, floorFlag); + {if (true) return node;} + throw new Error("Missing return statement in function"); + } + + void E() throws ParseException { + } + + List startList(Object o) throws ParseException { + List list = new ArrayList(); + list.add(o); + return list; + } + + protected SqlParserPos getPos() throws ParseException { + return new SqlParserPos( + token.beginLine, + token.beginColumn, + token.endLine, + token.endColumn); + } + + Span span() throws ParseException { + return Span.of(getPos()); + } + + void checkQueryExpression(ExprContext exprContext) throws ParseException { + switch (exprContext) { + case ACCEPT_NON_QUERY: + case ACCEPT_SUB_QUERY: + case ACCEPT_CURSOR: + throw SqlUtil.newContextException(getPos(), + RESOURCE.illegalQueryExpression()); + } + } + + void checkNonQueryExpression(ExprContext exprContext) throws ParseException { + switch (exprContext) { + case ACCEPT_QUERY: + throw SqlUtil.newContextException(getPos(), + RESOURCE.illegalNonQueryExpression()); + } + } + + SqlParseException convertException(Throwable ex) throws ParseException { + if (ex instanceof SqlParseException) { + return (SqlParseException) ex; + } + SqlParserPos pos = null; + int[][] expectedTokenSequences = null; + String[] tokenImage = null; + if (ex instanceof ParseException) { + ParseException pex = (ParseException) ex; + expectedTokenSequences = pex.expectedTokenSequences; + tokenImage = pex.tokenImage; + if (pex.currentToken != null) { + final Token token = pex.currentToken.next; + // Checks token.image.equals("1") to avoid recursive call. + // The SqlAbstractParserImpl#MetadataImpl constructor uses constant "1" to + // throw intentionally to collect the expected tokens. + if (!token.image.equals("1") + && getMetadata().isKeyword(token.image) + && SqlParserUtil.allowsIdentifier(tokenImage, expectedTokenSequences)) { + // If the next token is a keyword, reformat the error message as: + + // Incorrect syntax near the keyword '{keyword}' at line {line_number}, + // column {column_number}. + final String expecting = ex.getMessage() + .substring(ex.getMessage().indexOf("Was expecting")); + final String errorMsg = String.format("Incorrect syntax near the keyword '%s' " + + "at line %d, column %d.\n%s", + token.image, + token.beginLine, + token.beginColumn, + expecting); + // Replace the ParseException with explicit error message. + ex = new ParseException(errorMsg); + } + pos = new SqlParserPos( + token.beginLine, + token.beginColumn, + token.endLine, + token.endColumn); + } + } else if (ex instanceof TokenMgrError) { + TokenMgrError tme = (TokenMgrError) ex; + expectedTokenSequences = null; + tokenImage = null; + // Example: + // Lexical error at line 3, column 24. Encountered "#" after "a". + final java.util.regex.Pattern pattern = java.util.regex.Pattern.compile( + "(?s)Lexical error at line ([0-9]+), column ([0-9]+).*"); + java.util.regex.Matcher matcher = pattern.matcher(ex.getMessage()); + if (matcher.matches()) { + int line = Integer.parseInt(matcher.group(1)); + int column = Integer.parseInt(matcher.group(2)); + pos = new SqlParserPos(line, column, line, column); + } + } else if (ex instanceof CalciteContextException) { + // CalciteContextException is the standard wrapper for exceptions + // produced by the validator, but in the parser, the standard is + // SqlParseException; so, strip it away. In case you were wondering, + // the CalciteContextException appears because the parser + // occasionally calls into validator-style code such as + // SqlSpecialOperator.reduceExpr. + CalciteContextException ece = + (CalciteContextException) ex; + pos = new SqlParserPos( + ece.getPosLine(), + ece.getPosColumn(), + ece.getEndPosLine(), + ece.getEndPosColumn()); + ex = ece.getCause(); + } + + return new SqlParseException( + ex.getMessage(), pos, expectedTokenSequences, tokenImage, ex); + } + + ParseException cleanupParseException(ParseException ex) throws ParseException { + if (ex.expectedTokenSequences == null) { + return ex; + } + int iIdentifier = Arrays.asList(ex.tokenImage).indexOf(""); + + // Find all sequences in the error which contain identifier. For + // example, + // {} + // {A} + // {B, C} + // {D, } + // {D, A} + // {D, B} + // + // would yield + // {} + // {D} + boolean id = false; + final List prefixList = new ArrayList(); + for (int i = 0; i < ex.expectedTokenSequences.length; ++i) { + int[] seq = ex.expectedTokenSequences[i]; + int j = seq.length - 1; + int i1 = seq[j]; + if (i1 == iIdentifier) { + int[] prefix = new int[j]; + System.arraycopy(seq, 0, prefix, 0, j); + prefixList.add(prefix); + } + } + + if (prefixList.isEmpty()) { + return ex; + } + + int[][] prefixes = (int[][]) + prefixList.toArray(new int[prefixList.size()][]); + + // Since was one of the possible productions, + // we know that the parser will also have included all + // of the non-reserved keywords (which are treated as + // identifiers in non-keyword contexts). So, now we need + // to clean those out, since they're totally irrelevant. + + final List list = new ArrayList(); + Metadata metadata = getMetadata(); + for (int i = 0; i < ex.expectedTokenSequences.length; ++i) { + int [] seq = ex.expectedTokenSequences[i]; + String tokenImage = ex.tokenImage[seq[seq.length - 1]]; + String token = SqlParserUtil.getTokenVal(tokenImage); + if (token == null || !metadata.isNonReservedKeyword(token)) { + list.add(seq); + continue; + } + boolean match = matchesPrefix(seq, prefixes); + if (!match) { + list.add(seq); + } + } + + ex.expectedTokenSequences = + (int [][]) list.toArray(new int [list.size()][]); + return ex; + } + + boolean matchesPrefix(int[] seq, int[][] prefixes) throws ParseException { + nextPrefix: + for (int[] prefix : prefixes) { + if (seq.length == prefix.length + 1) { + for (int k = 0; k < prefix.length; k++) { + if (prefix[k] != seq[k]) { + continue nextPrefix; + } + } + return true; + } + } + return false; + } + +/***************************************** + * Syntactical Descriptions * + *****************************************/ + +/** + * Parses either a row expression or a query expression with an optional + * ORDER BY. + * + *

Postgres syntax for limit: + * + * 

+ *    [ LIMIT { count | ALL } ]
+ *    [ OFFSET start ]
+ *
+ * + *

MySQL syntax for limit: + * + * 

+ *    [ LIMIT { count | start, count } ]
+ *
+ * + *

SQL:2008 syntax for limit: + * + * 

+ *    [ OFFSET start { ROW | ROWS } ]
+ *    [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
+ *
+ */ + final public SqlNode OrderedQueryOrExpr(ExprContext exprContext) throws ParseException { + SqlNode e; + SqlNodeList orderBy = null; + SqlNode start = null; + SqlNode count = null; + e = QueryOrExpr(exprContext); + if (jj_2_1(2)) { + // use the syntactic type of the expression we just parsed + // to decide whether ORDER BY makes sense + orderBy = OrderBy(e.isA(SqlKind.QUERY)); + } else { + ; + } + if (jj_2_5(2)) { + jj_consume_token(LIMIT); + if (jj_2_2(2)) { + start = UnsignedNumericLiteralOrParam(); + jj_consume_token(COMMA); + count = UnsignedNumericLiteralOrParam(); + if (!this.conformance.isLimitStartCountAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.limitStartCountNotAllowed());} + } + } else if (jj_2_3(2)) { + count = UnsignedNumericLiteralOrParam(); + } else if (jj_2_4(2)) { + jj_consume_token(ALL); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + if (jj_2_9(2)) { + jj_consume_token(OFFSET); + start = UnsignedNumericLiteralOrParam(); + if (jj_2_8(2)) { + if (jj_2_6(2)) { + jj_consume_token(ROW); + } else if (jj_2_7(2)) { + jj_consume_token(ROWS); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + } else { + ; + } + if (jj_2_14(2)) { + jj_consume_token(FETCH); + if (jj_2_10(2)) { + jj_consume_token(FIRST); + } else if (jj_2_11(2)) { + jj_consume_token(NEXT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + count = UnsignedNumericLiteralOrParam(); + if (jj_2_12(2)) { + jj_consume_token(ROW); + } else if (jj_2_13(2)) { + jj_consume_token(ROWS); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(ONLY); + } else { + ; + } + if (orderBy != null || start != null || count != null) { + if (orderBy == null) { + orderBy = SqlNodeList.EMPTY; + } + e = new SqlOrderBy(getPos(), e, orderBy, start, count); + + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a leaf in a query expression (SELECT, VALUES or TABLE). + */ + final public SqlNode LeafQuery(ExprContext exprContext) throws ParseException { + SqlNode e; + if (jj_2_15(2)) { + // ensure a query is legal in this context + checkQueryExpression(exprContext); + e = SqlSelect(); + {if (true) return e;} + } else if (jj_2_16(2)) { + e = TableConstructor(); + {if (true) return e;} + } else if (jj_2_17(2)) { + e = ExplicitTable(getPos()); + {if (true) return e;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a parenthesized query or single row expression. + */ + final public SqlNode ParenthesizedExpression(ExprContext exprContext) throws ParseException { + SqlNode e; + jj_consume_token(LPAREN); + // we've now seen left paren, so queries inside should + // be allowed as sub-queries + switch (exprContext) { + case ACCEPT_SUB_QUERY: + exprContext = ExprContext.ACCEPT_NONCURSOR; + break; + case ACCEPT_CURSOR: + exprContext = ExprContext.ACCEPT_ALL; + break; + } + e = OrderedQueryOrExpr(exprContext); + jj_consume_token(RPAREN); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a parenthesized query or comma-list of row expressions. + * + *

REVIEW jvs 8-Feb-2004: There's a small hole in this production. It can be + * used to construct something like + * + * 

+ * WHERE x IN (select count(*) from t where c=d,5)
+ *
+ * + *

which should be illegal. The above is interpreted as equivalent to + * + * 

+ * WHERE x IN ((select count(*) from t where c=d),5)
+ *
+ * + *

which is a legal use of a sub-query. The only way to fix the hole is to + * be able to remember whether a subexpression was parenthesized or not, which + * means preserving parentheses in the SqlNode tree. This is probably + * desirable anyway for use in purely syntactic parsing applications (e.g. SQL + * pretty-printer). However, if this is done, it's important to also make + * isA() on the paren node call down to its operand so that we can + * always correctly discriminate a query from a row expression. + */ + final public SqlNodeList ParenthesizedQueryOrCommaList(ExprContext exprContext) throws ParseException { + SqlNode e; + List list; + ExprContext firstExprContext = exprContext; + final Span s; + jj_consume_token(LPAREN); + // we've now seen left paren, so a query by itself should + // be interpreted as a sub-query + s = span(); + switch (exprContext) { + case ACCEPT_SUB_QUERY: + firstExprContext = ExprContext.ACCEPT_NONCURSOR; + break; + case ACCEPT_CURSOR: + firstExprContext = ExprContext.ACCEPT_ALL; + break; + } + e = OrderedQueryOrExpr(firstExprContext); + list = startList(e); + label_1: + while (true) { + if (jj_2_18(2)) { + ; + } else { + break label_1; + } + jj_consume_token(COMMA); + // a comma-list can't appear where only a query is expected + checkNonQueryExpression(exprContext); + e = Expression(exprContext); + list.add(e); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** As ParenthesizedQueryOrCommaList, but allows DEFAULT + * in place of any of the expressions. For example, + * {@code (x, DEFAULT, null, DEFAULT)}. */ + final public SqlNodeList ParenthesizedQueryOrCommaListWithDefault(ExprContext exprContext) throws ParseException { + SqlNode e; + List list; + ExprContext firstExprContext = exprContext; + final Span s; + jj_consume_token(LPAREN); + // we've now seen left paren, so a query by itself should + // be interpreted as a sub-query + s = span(); + switch (exprContext) { + case ACCEPT_SUB_QUERY: + firstExprContext = ExprContext.ACCEPT_NONCURSOR; + break; + case ACCEPT_CURSOR: + firstExprContext = ExprContext.ACCEPT_ALL; + break; + } + if (jj_2_19(2)) { + e = OrderedQueryOrExpr(firstExprContext); + } else if (jj_2_20(2)) { + e = Default(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + list = startList(e); + label_2: + while (true) { + if (jj_2_21(2)) { + ; + } else { + break label_2; + } + jj_consume_token(COMMA); + // a comma-list can't appear where only a query is expected + checkNonQueryExpression(exprContext); + if (jj_2_22(2)) { + e = Expression(exprContext); + } else if (jj_2_23(2)) { + e = Default(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + list.add(e); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** + * Parses function parameter lists. + * If the list starts with DISTINCT or ALL, it is discarded. + */ + final public List UnquantifiedFunctionParameterList(ExprContext exprContext) throws ParseException { + final List args; + args = FunctionParameterList(exprContext); + final SqlLiteral quantifier = (SqlLiteral) args.get(0); + args.remove(0); // remove DISTINCT or ALL, if present + {if (true) return args;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses function parameter lists including DISTINCT keyword recognition, + * DEFAULT, and named argument assignment. + */ + final public List FunctionParameterList(ExprContext exprContext) throws ParseException { + final SqlLiteral qualifier; + final List list = new ArrayList(); + jj_consume_token(LPAREN); + if (jj_2_24(2)) { + qualifier = AllOrDistinct(); + list.add(qualifier); + } else { + list.add(null); + } + Arg0(list, exprContext); + label_3: + while (true) { + if (jj_2_25(2)) { + ; + } else { + break label_3; + } + jj_consume_token(COMMA); + // a comma-list can't appear where only a query is expected + checkNonQueryExpression(exprContext); + Arg(list, exprContext); + } + jj_consume_token(RPAREN); + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlLiteral AllOrDistinct() throws ParseException { + if (jj_2_26(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlSelectKeyword.DISTINCT.symbol(getPos());} + } else if (jj_2_27(2)) { + jj_consume_token(ALL); + {if (true) return SqlSelectKeyword.ALL.symbol(getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public void Arg0(List list, ExprContext exprContext) throws ParseException { + SqlIdentifier name = null; + SqlNode e = null; + final ExprContext firstExprContext; + { + // we've now seen left paren, so queries inside should + // be allowed as sub-queries + switch (exprContext) { + case ACCEPT_SUB_QUERY: + firstExprContext = ExprContext.ACCEPT_NONCURSOR; + break; + case ACCEPT_CURSOR: + firstExprContext = ExprContext.ACCEPT_ALL; + break; + default: + firstExprContext = exprContext; + break; + } + } + if (jj_2_28(2)) { + name = SimpleIdentifier(); + jj_consume_token(NAMED_ARGUMENT_ASSIGNMENT); + } else { + ; + } + if (jj_2_29(2)) { + e = Default(); + } else if (jj_2_30(2)) { + e = OrderedQueryOrExpr(firstExprContext); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (e != null) { + if (name != null) { + e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall( + Span.of(name, e).pos(), e, name); + } + list.add(e); + } + } + + final public void Arg(List list, ExprContext exprContext) throws ParseException { + SqlIdentifier name = null; + SqlNode e = null; + if (jj_2_31(2)) { + name = SimpleIdentifier(); + jj_consume_token(NAMED_ARGUMENT_ASSIGNMENT); + } else { + ; + } + if (jj_2_32(2)) { + e = Default(); + } else if (jj_2_33(2)) { + e = Expression(exprContext); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (e != null) { + if (name != null) { + e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall( + Span.of(name, e).pos(), e, name); + } + list.add(e); + } + } + + final public SqlNode Default() throws ParseException { + jj_consume_token(DEFAULT_); + {if (true) return SqlStdOperatorTable.DEFAULT.createCall(getPos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a query (SELECT, UNION, INTERSECT, EXCEPT, VALUES, TABLE) followed by + * the end-of-file symbol. + */ + final public SqlNode SqlQueryEof() throws ParseException { + SqlNode query; + query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY); + jj_consume_token(0); + {if (true) return query;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a list of SQL statements separated by semicolon. + * The semicolon is required between statements, but is + * optional at the end. + */ + final public SqlNodeList SqlStmtList() throws ParseException { + final List stmtList = new ArrayList(); + SqlNode stmt; + stmt = SqlStmt(); + stmtList.add(stmt); + label_4: + while (true) { + if (jj_2_34(2)) { + ; + } else { + break label_4; + } + jj_consume_token(SEMICOLON); + if (jj_2_35(2)) { + stmt = SqlStmt(); + stmtList.add(stmt); + } else { + ; + } + } + jj_consume_token(0); + {if (true) return new SqlNodeList(stmtList, Span.of(stmtList).pos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an SQL statement. + */ + final public SqlNode SqlStmt() throws ParseException { + SqlNode stmt; + if (jj_2_36(2)) { + stmt = SqlAlterTable(); + } else if (jj_2_37(2)) { + stmt = SqlAlterUser(); + } else if (jj_2_38(2)) { + stmt = SqlKillScanQuery(); + } else if (jj_2_39(2)) { + stmt = SqlKillContinuousQuery(); + } else if (jj_2_40(2)) { + stmt = SqlKillService(); + } else if (jj_2_41(2)) { + stmt = SqlKillTransaction(); + } else if (jj_2_42(2)) { + stmt = SqlKillComputeTask(); + } else if (jj_2_43(2)) { + stmt = SqlKillQuery(); + } else if (jj_2_44(2)) { + stmt = SqlCommitTransaction(); + } else if (jj_2_45(2)) { + stmt = SqlRollbackTransaction(); + } else if (jj_2_46(2)) { + stmt = SqlSetOption(Span.of(), null); + } else if (jj_2_47(2)) { + stmt = SqlAlter(); + } else if (jj_2_48(2)) { + stmt = SqlCreate(); + } else if (jj_2_49(2)) { + stmt = SqlDrop(); + } else if (jj_2_50(2)) { + stmt = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY); + } else if (jj_2_51(2)) { + stmt = SqlExplain(); + } else if (jj_2_52(2)) { + stmt = SqlDescribe(); + } else if (jj_2_53(2)) { + stmt = SqlInsert(); + } else if (jj_2_54(2)) { + stmt = SqlDelete(); + } else if (jj_2_55(2)) { + stmt = SqlUpdate(); + } else if (jj_2_56(2)) { + stmt = SqlMerge(); + } else if (jj_2_57(2)) { + stmt = SqlProcedureCall(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return stmt;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an SQL statement followed by the end-of-file symbol. + */ + final public SqlNode SqlStmtEof() throws ParseException { + SqlNode stmt; + stmt = SqlStmt(); + jj_consume_token(0); + {if (true) return stmt;} + throw new Error("Missing return statement in function"); + } + + final public boolean IfNotExistsOpt() throws ParseException { + if (jj_2_58(2)) { + jj_consume_token(IF); + jj_consume_token(NOT); + jj_consume_token(EXISTS); + {if (true) return true;} + } else { + {if (true) return false;} + } + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList WithCreateTableOptionList() throws ParseException { + List list = new ArrayList(); + final Span s; + if (jj_2_60(2)) { + jj_consume_token(WITH); + s = span(); + CreateTableOption(list); + label_5: + while (true) { + if (jj_2_59(2)) { + ; + } else { + break label_5; + } + jj_consume_token(COMMA); + s.add(this); + CreateTableOption(list); + } + {if (true) return new SqlNodeList(list, s.end(this));} + } else { + ; + } + {if (true) return null;} + throw new Error("Missing return statement in function"); + } + + final public SqlLiteral CreateTableOptionKey() throws ParseException { + if (jj_2_61(2)) { + jj_consume_token(TEMPLATE); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.TEMPLATE, getPos());} + } else if (jj_2_62(2)) { + jj_consume_token(BACKUPS); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.BACKUPS, getPos());} + } else if (jj_2_63(2)) { + jj_consume_token(AFFINITY_KEY); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.AFFINITY_KEY, getPos());} + } else if (jj_2_64(2)) { + jj_consume_token(ATOMICITY); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.ATOMICITY, getPos());} + } else if (jj_2_65(2)) { + jj_consume_token(WRITE_SYNCHRONIZATION_MODE); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.WRITE_SYNCHRONIZATION_MODE, getPos());} + } else if (jj_2_66(2)) { + jj_consume_token(CACHE_GROUP); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.CACHE_GROUP, getPos());} + } else if (jj_2_67(2)) { + jj_consume_token(CACHE_NAME); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.CACHE_NAME, getPos());} + } else if (jj_2_68(2)) { + jj_consume_token(DATA_REGION); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.DATA_REGION, getPos());} + } else if (jj_2_69(2)) { + jj_consume_token(KEY_TYPE); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.KEY_TYPE, getPos());} + } else if (jj_2_70(2)) { + jj_consume_token(VALUE_TYPE); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.VALUE_TYPE, getPos());} + } else if (jj_2_71(2)) { + jj_consume_token(ENCRYPTED); + {if (true) return SqlLiteral.createSymbol(IgniteSqlCreateTableOptionEnum.ENCRYPTED, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public void CreateTableOption(List list) throws ParseException { + final Span s; + final SqlLiteral key; + final SqlNode val; + key = CreateTableOptionKey(); + s = span(); + jj_consume_token(EQ); + if (jj_2_72(2)) { + val = Literal(); + } else if (jj_2_73(2)) { + val = SimpleIdentifier(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + list.add(new IgniteSqlCreateTableOption(key, val, s.end(this))); + } + + final public SqlDataTypeSpec DataTypeEx() throws ParseException { + final SqlDataTypeSpec dt; + if (jj_2_74(2)) { + dt = DataType(); + } else if (jj_2_75(2)) { + dt = IntervalType(); + } else if (jj_2_76(2)) { + dt = UuidType(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return dt;} + throw new Error("Missing return statement in function"); + } + + final public SqlDataTypeSpec IntervalType() throws ParseException { + final Span s; + final SqlIntervalQualifier intervalQualifier; + jj_consume_token(INTERVAL); + s = span(); + intervalQualifier = IntervalQualifier(); + {if (true) return new SqlDataTypeSpec(new IgniteSqlIntervalTypeNameSpec(intervalQualifier, s.end(this)), s.pos());} + throw new Error("Missing return statement in function"); + } + + final public SqlDataTypeSpec UuidType() throws ParseException { + final Span s; + jj_consume_token(UUID); + s = span(); + {if (true) return new SqlDataTypeSpec(new SqlUserDefinedTypeNameSpec("UUID", s.end(this)), s.pos());} + throw new Error("Missing return statement in function"); + } + + final public void TableElement(List list) throws ParseException { + final SqlDataTypeSpec type; + final boolean nullable; + final SqlNodeList columnList; + final Span s = Span.of(); + final ColumnStrategy strategy; + final SqlNode dflt; + SqlIdentifier id = null; + if (jj_2_80(2)) { + id = SimpleIdentifier(); + type = DataTypeEx(); + nullable = NullableOptDefaultTrue(); + if (jj_2_77(2)) { + jj_consume_token(DEFAULT_); + s.add(this); + dflt = Literal(); + strategy = ColumnStrategy.DEFAULT; + } else { + dflt = null; + strategy = nullable ? ColumnStrategy.NULLABLE + : ColumnStrategy.NOT_NULLABLE; + } + if (jj_2_78(2)) { + jj_consume_token(PRIMARY); + s.add(this); + jj_consume_token(KEY); + columnList = SqlNodeList.of(id); + list.add(SqlDdlNodes.primary(s.end(columnList), null, columnList)); + } else { + ; + } + list.add( + SqlDdlNodes.column(s.add(id).end(this), id, + type.withNullable(nullable), dflt, strategy)); + } else if (jj_2_81(2)) { + if (jj_2_79(2)) { + jj_consume_token(CONSTRAINT); + s.add(this); + id = SimpleIdentifier(); + } else { + ; + } + jj_consume_token(PRIMARY); + s.add(this); + jj_consume_token(KEY); + columnList = ParenthesizedSimpleIdentifierList(); + list.add(SqlDdlNodes.primary(s.end(columnList), id, columnList)); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + + final public SqlNodeList TableElementList() throws ParseException { + final Span s; + final List list = new ArrayList(); + jj_consume_token(LPAREN); + s = span(); + TableElement(list); + label_6: + while (true) { + if (jj_2_82(2)) { + ; + } else { + break label_6; + } + jj_consume_token(COMMA); + TableElement(list); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlCreate SqlCreateTable(Span s, boolean replace) throws ParseException { + final boolean ifNotExists; + final SqlIdentifier id; + final SqlNodeList columnList; + final SqlNodeList optionList; + final SqlNode query; + jj_consume_token(TABLE); + ifNotExists = IfNotExistsOpt(); + id = CompoundIdentifier(); + if (jj_2_84(3)) { + columnList = TableElementList(); + optionList = WithCreateTableOptionList(); + query = null; + } else if (jj_2_85(2)) { + if (jj_2_83(2)) { + columnList = ParenthesizedSimpleIdentifierList(); + } else { + columnList = null; + } + optionList = WithCreateTableOptionList(); + jj_consume_token(AS); + s.add(this); + query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new IgniteSqlCreateTable(s.end(this), ifNotExists, id, columnList, query, optionList);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode IndexedColumn() throws ParseException { + final Span s; + SqlNode col; + col = SimpleIdentifier(); + if (jj_2_88(2)) { + if (jj_2_86(2)) { + jj_consume_token(ASC); + } else if (jj_2_87(2)) { + jj_consume_token(DESC); + col = SqlStdOperatorTable.DESC.createCall(getPos(), col); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return col;} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList IndexedColumnList() throws ParseException { + final Span s; + final List list = new ArrayList(); + SqlNode col = null; + jj_consume_token(LPAREN); + s = span(); + col = IndexedColumn(); + list.add(col); + label_7: + while (true) { + if (jj_2_89(2)) { + ; + } else { + break label_7; + } + jj_consume_token(COMMA); + col = IndexedColumn(); + list.add(col); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlCreate SqlCreateIndex(Span s, boolean replace) throws ParseException { + final boolean ifNotExists; + final SqlIdentifier idxId; + final SqlIdentifier tblId; + final SqlNodeList columnList; + SqlNumericLiteral parallel = null; + SqlNumericLiteral inlineSize = null; + jj_consume_token(INDEX); + ifNotExists = IfNotExistsOpt(); + idxId = SimpleIdentifier(); + jj_consume_token(ON); + tblId = CompoundIdentifier(); + columnList = IndexedColumnList(); + label_8: + while (true) { + if (jj_2_90(2)) { + ; + } else { + break label_8; + } + if (jj_2_91(2)) { + jj_consume_token(PARALLEL); + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + if (parallel != null) + {if (true) throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.optionAlreadyDefined("PARALLEL"));} + + parallel = SqlLiteral.createExactNumeric(token.image, getPos()); + } else if (jj_2_92(2)) { + jj_consume_token(INLINE_SIZE); + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + if (inlineSize != null) + {if (true) throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.optionAlreadyDefined("INLINE_SIZE"));} + + inlineSize = SqlLiteral.createExactNumeric(token.image, getPos()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new IgniteSqlCreateIndex(s.end(this), ifNotExists, idxId, tblId, columnList, parallel, inlineSize);} + throw new Error("Missing return statement in function"); + } + + final public boolean IfExistsOpt() throws ParseException { + if (jj_2_93(2)) { + jj_consume_token(IF); + jj_consume_token(EXISTS); + {if (true) return true;} + } else { + {if (true) return false;} + } + throw new Error("Missing return statement in function"); + } + + final public SqlDrop SqlDropTable(Span s, boolean replace) throws ParseException { + final boolean ifExists; + final SqlIdentifier id; + jj_consume_token(TABLE); + ifExists = IfExistsOpt(); + id = CompoundIdentifier(); + {if (true) return SqlDdlNodes.dropTable(s.end(this), ifExists, id);} + throw new Error("Missing return statement in function"); + } + + final public SqlDrop SqlDropIndex(Span s, boolean replace) throws ParseException { + final boolean ifExists; + final SqlIdentifier id; + jj_consume_token(INDEX); + ifExists = IfExistsOpt(); + id = CompoundIdentifier(); + {if (true) return new IgniteSqlDropIndex(s.end(this), ifExists, id);} + throw new Error("Missing return statement in function"); + } + + final public void InfixCast(List list, ExprContext exprContext, Span s) throws ParseException { + final SqlDataTypeSpec dt; + jj_consume_token(INFIX_CAST); + checkNonQueryExpression(exprContext); + dt = DataTypeEx(); + list.add( + new SqlParserUtil.ToTreeListItem(SqlLibraryOperators.INFIX_CAST, + s.pos())); + list.add(dt); + } + + final public SqlNodeList ColumnWithTypeList() throws ParseException { + final Span s; + List list = new ArrayList(); + SqlNode col; + jj_consume_token(LPAREN); + s = span(); + col = ColumnWithType(); + list.add(col); + label_9: + while (true) { + if (jj_2_94(2)) { + ; + } else { + break label_9; + } + jj_consume_token(COMMA); + col = ColumnWithType(); + list.add(col); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlNode ColumnWithType() throws ParseException { + SqlIdentifier id; + SqlDataTypeSpec type; + boolean nullable = true; + final Span s = Span.of(); + id = SimpleIdentifier(); + type = DataTypeEx(); + if (jj_2_95(2)) { + jj_consume_token(NOT); + jj_consume_token(NULL); + nullable = false; + } else { + ; + } + {if (true) return SqlDdlNodes.column(s.add(id).end(this), id, type.withNullable(nullable), null, null);} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList ColumnWithTypeOrList() throws ParseException { + SqlNode col; + SqlNodeList list; + if (jj_2_96(2)) { + col = ColumnWithType(); + {if (true) return new SqlNodeList(Collections.singletonList(col), col.getParserPosition());} + } else if (jj_2_97(2)) { + list = ColumnWithTypeList(); + {if (true) return list;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlAlterTable() throws ParseException { + final Span s; + final boolean ifExists; + final SqlIdentifier id; + boolean colIgnoreErr; + SqlNode col; + SqlNodeList cols; + jj_consume_token(ALTER); + s = span(); + jj_consume_token(TABLE); + ifExists = IfExistsOpt(); + id = CompoundIdentifier(); + if (jj_2_100(2)) { + jj_consume_token(LOGGING); + {if (true) return new IgniteSqlAlterTable(s.end(this), ifExists, id, true);} + } else if (jj_2_101(2)) { + jj_consume_token(NOLOGGING); + {if (true) return new IgniteSqlAlterTable(s.end(this), ifExists, id, false);} + } else if (jj_2_102(2)) { + jj_consume_token(ADD); + if (jj_2_98(2)) { + jj_consume_token(COLUMN); + } else { + ; + } + colIgnoreErr = IfNotExistsOpt(); + cols = ColumnWithTypeOrList(); + {if (true) return new IgniteSqlAlterTableAddColumn(s.end(this), ifExists, id, colIgnoreErr, cols);} + } else if (jj_2_103(2)) { + jj_consume_token(DROP); + if (jj_2_99(2)) { + jj_consume_token(COLUMN); + } else { + ; + } + colIgnoreErr = IfExistsOpt(); + cols = SimpleIdentifierOrList(); + {if (true) return new IgniteSqlAlterTableDropColumn(s.end(this), ifExists, id, colIgnoreErr, cols);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCreate SqlCreateUser(Span s, boolean replace) throws ParseException { + final SqlIdentifier user; + final SqlNode password; + jj_consume_token(USER); + user = SimpleIdentifier(); + jj_consume_token(WITH); + jj_consume_token(PASSWORD); + password = StringLiteral(); + {if (true) return new IgniteSqlCreateUser(s.end(this), user, SqlLiteral.unchain(password));} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlAlterUser() throws ParseException { + final Span s; + final SqlIdentifier user; + final SqlNode password; + jj_consume_token(ALTER); + s = span(); + jj_consume_token(USER); + user = SimpleIdentifier(); + jj_consume_token(WITH); + jj_consume_token(PASSWORD); + password = StringLiteral(); + {if (true) return new IgniteSqlAlterUser(s.end(this), user, SqlLiteral.unchain(password));} + throw new Error("Missing return statement in function"); + } + + final public SqlDrop SqlDropUser(Span s, boolean replace) throws ParseException { + final SqlIdentifier user; + jj_consume_token(USER); + user = SimpleIdentifier(); + {if (true) return new IgniteSqlDropUser(s.end(this), user);} + throw new Error("Missing return statement in function"); + } + + final public SqlNumericLiteral SignedIntegerLiteral() throws ParseException { + final Span s; + if (jj_2_104(2)) { + jj_consume_token(PLUS); + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + {if (true) return SqlLiteral.createExactNumeric(token.image, getPos());} + } else if (jj_2_105(2)) { + jj_consume_token(MINUS); + s = span(); + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + {if (true) return SqlLiteral.createNegative(SqlLiteral.createExactNumeric(token.image, getPos()), s.end(this));} + } else if (jj_2_106(2)) { + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + {if (true) return SqlLiteral.createExactNumeric(token.image, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCharStringLiteral UuidLiteral() throws ParseException { + final Span s; + final String rawUuuid; + jj_consume_token(QUOTED_STRING); + String rawUuid = SqlParserUtil.parseString(token.image); + try { + java.util.UUID.fromString(rawUuid); + {if (true) return SqlLiteral.createCharString(rawUuid, getPos());} + } + catch (Exception e) { + {if (true) throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.illegalUuid(rawUuid));} + } + throw new Error("Missing return statement in function"); + } + + final public SqlCharStringLiteral IgniteUuidLiteral() throws ParseException { + final Span s; + final String rawUuuid; + jj_consume_token(QUOTED_STRING); + String rawUuid = SqlParserUtil.parseString(token.image); + try { + IgniteUuid.fromString(rawUuid); + {if (true) return SqlLiteral.createCharString(rawUuid, getPos());} + } + catch (Exception e) { + {if (true) throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.illegalIgniteUuid(rawUuid));} + } + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillScanQuery() throws ParseException { + final Span s; + final SqlCharStringLiteral originNodeId; + final SqlCharStringLiteral cacheName; + final SqlNumericLiteral queryId; + jj_consume_token(KILL); + s = span(); + jj_consume_token(SCAN); + originNodeId = UuidLiteral(); + jj_consume_token(QUOTED_STRING); + cacheName = SqlLiteral.createCharString(SqlParserUtil.parseString(token.image), getPos()); + queryId = SignedIntegerLiteral(); + {if (true) return IgniteSqlKill.createScanQueryKill(s.end(this), originNodeId, cacheName, queryId);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillContinuousQuery() throws ParseException { + final Span s; + final SqlCharStringLiteral originNodeId; + final SqlCharStringLiteral routineId; + jj_consume_token(KILL); + s = span(); + jj_consume_token(CONTINUOUS); + originNodeId = UuidLiteral(); + routineId = UuidLiteral(); + {if (true) return IgniteSqlKill.createContinuousQueryKill(s.end(this), originNodeId, routineId);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillTransaction() throws ParseException { + final Span s; + final SqlCharStringLiteral xid; + jj_consume_token(KILL); + s = span(); + jj_consume_token(TRANSACTION); + xid = IgniteUuidLiteral(); + {if (true) return IgniteSqlKill.createTransactionKill(s.end(this), xid);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillService() throws ParseException { + final Span s; + final SqlCharStringLiteral srvName; + jj_consume_token(KILL); + s = span(); + jj_consume_token(SERVICE); + jj_consume_token(QUOTED_STRING); + srvName = SqlLiteral.createCharString(SqlParserUtil.parseString(token.image), getPos()); + {if (true) return IgniteSqlKill.createServiceKill(s.end(this), srvName);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillComputeTask() throws ParseException { + final Span s; + final SqlCharStringLiteral sesId; + jj_consume_token(KILL); + s = span(); + jj_consume_token(COMPUTE); + sesId = IgniteUuidLiteral(); + {if (true) return IgniteSqlKill.createComputeTaskKill(s.end(this), sesId);} + throw new Error("Missing return statement in function"); + } + + final public boolean IsAsyncOpt() throws ParseException { + if (jj_2_107(2)) { + jj_consume_token(ASYNC); + {if (true) return true;} + } else { + {if (true) return false;} + } + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlKillQuery() throws ParseException { + final Span s; + final boolean isAsync; + jj_consume_token(KILL); + s = span(); + jj_consume_token(QUERY); + isAsync = IsAsyncOpt(); + jj_consume_token(QUOTED_STRING); + String rawQueryId = SqlParserUtil.parseString(token.image); + SqlCharStringLiteral queryIdLiteral = SqlLiteral.createCharString(rawQueryId, getPos()); + Pair id = IgniteSqlKill.parseGlobalQueryId(rawQueryId); + if (id == null) { + {if (true) throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.illegalGlobalQueryId(rawQueryId));} + } + {if (true) return IgniteSqlKill.createQueryKill(s.end(this), queryIdLiteral, id.getKey(), id.getValue(), isAsync);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlCommitTransaction() throws ParseException { + final Span s; + jj_consume_token(COMMIT); + s = span(); + if (jj_2_108(2)) { + jj_consume_token(TRANSACTION); + } else { + ; + } + {if (true) return new IgniteSqlCommit(s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SqlRollbackTransaction() throws ParseException { + final Span s; + jj_consume_token(ROLLBACK); + s = span(); + if (jj_2_109(2)) { + jj_consume_token(TRANSACTION); + } else { + ; + } + {if (true) return new IgniteSqlRollback(s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList ParenthesizedKeyValueOptionCommaList() throws ParseException { + final Span s; + final List list = new ArrayList(); + s = span(); + jj_consume_token(LPAREN); + KeyValueOption(list); + label_10: + while (true) { + if (jj_2_110(2)) { + ; + } else { + break label_10; + } + jj_consume_token(COMMA); + KeyValueOption(list); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** +* Parses an option with format key=val whose key is a simple identifier or string literal +* and value is a string literal. +*/ + final public void KeyValueOption(List list) throws ParseException { + final SqlNode key; + final SqlNode value; + if (jj_2_111(2)) { + key = SimpleIdentifier(); + } else if (jj_2_112(2)) { + key = StringLiteral(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(EQ); + value = StringLiteral(); + list.add(key); + list.add(value); + } + +/** +* Parses an option value, it's either a string or a numeric. +*/ + final public SqlNode OptionValue() throws ParseException { + final SqlNode value; + if (jj_2_113(2)) { + value = NumericLiteral(); + } else if (jj_2_114(2)) { + value = StringLiteral(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return value;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a literal list separated by comma. The literal is either a string or a numeric. + */ + final public SqlNodeList ParenthesizedLiteralOptionCommaList() throws ParseException { + final Span s; + final List list = new ArrayList(); + SqlNode optionVal; + s = span(); + jj_consume_token(LPAREN); + optionVal = OptionValue(); + list.add(optionVal); + label_11: + while (true) { + if (jj_2_115(2)) { + ; + } else { + break label_11; + } + jj_consume_token(COMMA); + optionVal = OptionValue(); + list.add(optionVal); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public void CommaSeparatedSqlHints(List hints) throws ParseException { + SqlIdentifier hintName; + SqlNodeList hintOptions; + SqlNode optionVal; + SqlHint.HintOptionFormat optionFormat; + hintName = SimpleIdentifier(); + if (jj_2_117(5)) { + hintOptions = ParenthesizedKeyValueOptionCommaList(); + optionFormat = SqlHint.HintOptionFormat.KV_LIST; + } else if (jj_2_118(3)) { + hintOptions = ParenthesizedSimpleIdentifierList(); + optionFormat = SqlHint.HintOptionFormat.ID_LIST; + } else if (jj_2_119(3)) { + hintOptions = ParenthesizedLiteralOptionCommaList(); + optionFormat = SqlHint.HintOptionFormat.LITERAL_LIST; + } else { + if (jj_2_116(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + } else { + ; + } + hintOptions = SqlNodeList.EMPTY; + optionFormat = SqlHint.HintOptionFormat.EMPTY; + } + hints.add(new SqlHint(Span.of(hintOptions).end(this), hintName, hintOptions, optionFormat)); + label_12: + while (true) { + if (jj_2_120(2)) { + ; + } else { + break label_12; + } + jj_consume_token(COMMA); + hintName = SimpleIdentifier(); + if (jj_2_122(5)) { + hintOptions = ParenthesizedKeyValueOptionCommaList(); + optionFormat = SqlHint.HintOptionFormat.KV_LIST; + } else if (jj_2_123(3)) { + hintOptions = ParenthesizedSimpleIdentifierList(); + optionFormat = SqlHint.HintOptionFormat.ID_LIST; + } else if (jj_2_124(3)) { + hintOptions = ParenthesizedLiteralOptionCommaList(); + optionFormat = SqlHint.HintOptionFormat.LITERAL_LIST; + } else { + if (jj_2_121(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + } else { + ; + } + hintOptions = SqlNodeList.EMPTY; + optionFormat = SqlHint.HintOptionFormat.EMPTY; + } + hints.add(new SqlHint(Span.of(hintOptions).end(this), hintName, hintOptions, optionFormat)); + } + } + +/** + * Parses a table reference with optional hints. + */ + final public SqlNode TableRefWithHintsOpt() throws ParseException { + SqlNode tableRef; + SqlNodeList hintList; + final List hints = new ArrayList(); + final Span s; + s = span(); + tableRef = CompoundTableIdentifier(); + if (jj_2_125(2)) { + jj_consume_token(HINT_BEG); + CommaSeparatedSqlHints(hints); + jj_consume_token(COMMENT_END); + hintList = new SqlNodeList(hints, s.addAll(hints).end(this)); + tableRef = new SqlTableRef(Span.of(tableRef, hintList).pos(), + (SqlIdentifier) tableRef, hintList); + } else { + ; + } + {if (true) return tableRef;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a leaf SELECT expression without ORDER BY. + */ + final public SqlSelect SqlSelect() throws ParseException { + final List keywords = new ArrayList(); + final SqlLiteral keyword; + final SqlNodeList keywordList; + List selectList; + final SqlNode fromClause; + final SqlNode where; + final SqlNodeList groupBy; + final SqlNode having; + final SqlNodeList windowDecls; + final List hints = new ArrayList(); + final Span s; + jj_consume_token(SELECT); + s = span(); + if (jj_2_126(2)) { + jj_consume_token(HINT_BEG); + CommaSeparatedSqlHints(hints); + jj_consume_token(COMMENT_END); + } else { + ; + } + SqlSelectKeywords(keywords); + if (jj_2_127(2)) { + jj_consume_token(STREAM); + keywords.add(SqlSelectKeyword.STREAM.symbol(getPos())); + } else { + ; + } + if (jj_2_128(2)) { + keyword = AllOrDistinct(); + keywords.add(keyword); + } else { + ; + } + keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos()); + selectList = SelectList(); + if (jj_2_129(2)) { + jj_consume_token(FROM); + fromClause = FromClause(); + where = WhereOpt(); + groupBy = GroupByOpt(); + having = HavingOpt(); + windowDecls = WindowOpt(); + } else { + E(); + fromClause = null; + where = null; + groupBy = null; + having = null; + windowDecls = null; + } + {if (true) return new SqlSelect(s.end(this), keywordList, + new SqlNodeList(selectList, Span.of(selectList).pos()), + fromClause, where, groupBy, having, windowDecls, null, null, null, + new SqlNodeList(hints, getPos()));} + throw new Error("Missing return statement in function"); + } + +/* + * Abstract production: + * + * void SqlSelectKeywords(List keywords) + * + * Parses dialect-specific keywords immediately following the SELECT keyword. + */ + +/** + * Parses an EXPLAIN PLAN statement. + */ + final public SqlNode SqlExplain() throws ParseException { + SqlNode stmt; + SqlExplainLevel detailLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES; + SqlExplain.Depth depth; + final SqlExplainFormat format; + jj_consume_token(EXPLAIN); + jj_consume_token(PLAN); + if (jj_2_130(2)) { + detailLevel = ExplainDetailLevel(); + } else { + ; + } + depth = ExplainDepth(); + if (jj_2_131(2)) { + jj_consume_token(AS); + jj_consume_token(XML); + format = SqlExplainFormat.XML; + } else if (jj_2_132(2)) { + jj_consume_token(AS); + jj_consume_token(JSON); + format = SqlExplainFormat.JSON; + } else if (jj_2_133(2)) { + jj_consume_token(AS); + jj_consume_token(DOT_FORMAT); + format = SqlExplainFormat.DOT; + } else { + format = SqlExplainFormat.TEXT; + } + jj_consume_token(FOR); + stmt = SqlQueryOrDml(); + {if (true) return new SqlExplain(getPos(), + stmt, + detailLevel.symbol(SqlParserPos.ZERO), + depth.symbol(SqlParserPos.ZERO), + format.symbol(SqlParserPos.ZERO), + nDynamicParams);} + throw new Error("Missing return statement in function"); + } + +/** Parses a query (SELECT or VALUES) + * or DML statement (INSERT, UPDATE, DELETE, MERGE). */ + final public SqlNode SqlQueryOrDml() throws ParseException { + SqlNode stmt; + if (jj_2_134(2)) { + stmt = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY); + } else if (jj_2_135(2)) { + stmt = SqlInsert(); + } else if (jj_2_136(2)) { + stmt = SqlDelete(); + } else if (jj_2_137(2)) { + stmt = SqlUpdate(); + } else if (jj_2_138(2)) { + stmt = SqlMerge(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return stmt;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses WITH TYPE | WITH IMPLEMENTATION | WITHOUT IMPLEMENTATION modifier for + * EXPLAIN PLAN. + */ + final public SqlExplain.Depth ExplainDepth() throws ParseException { + if (jj_2_139(2)) { + jj_consume_token(WITH); + jj_consume_token(TYPE); + {if (true) return SqlExplain.Depth.TYPE;} + } else if (jj_2_140(2)) { + jj_consume_token(WITH); + jj_consume_token(IMPLEMENTATION); + {if (true) return SqlExplain.Depth.PHYSICAL;} + } else if (jj_2_141(2)) { + jj_consume_token(WITHOUT); + jj_consume_token(IMPLEMENTATION); + {if (true) return SqlExplain.Depth.LOGICAL;} + } else { + {if (true) return SqlExplain.Depth.PHYSICAL;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses INCLUDING ALL ATTRIBUTES modifier for EXPLAIN PLAN. + */ + final public SqlExplainLevel ExplainDetailLevel() throws ParseException { + SqlExplainLevel level = SqlExplainLevel.EXPPLAN_ATTRIBUTES; + if (jj_2_143(2)) { + jj_consume_token(EXCLUDING); + jj_consume_token(ATTRIBUTES); + level = SqlExplainLevel.NO_ATTRIBUTES; + } else if (jj_2_144(2)) { + jj_consume_token(INCLUDING); + if (jj_2_142(2)) { + jj_consume_token(ALL); + level = SqlExplainLevel.ALL_ATTRIBUTES; + } else { + ; + } + jj_consume_token(ATTRIBUTES); + + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return level;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a DESCRIBE statement. + */ + final public SqlNode SqlDescribe() throws ParseException { + final Span s; + final SqlIdentifier table; + final SqlIdentifier column; + final SqlIdentifier id; + final SqlNode stmt; + jj_consume_token(DESCRIBE); + s = span(); + if (jj_2_150(2)) { + if (jj_2_145(2)) { + jj_consume_token(DATABASE); + } else if (jj_2_146(2)) { + jj_consume_token(CATALOG); + } else if (jj_2_147(2)) { + jj_consume_token(SCHEMA); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + id = CompoundIdentifier(); + // DESCRIBE DATABASE and DESCRIBE CATALOG currently do the same as + // DESCRIBE SCHEMA but should be different. See + // [CALCITE-1221] Implement DESCRIBE DATABASE, CATALOG, STATEMENT + {if (true) return new SqlDescribeSchema(s.end(id), id);} + } else if (jj_2_151(2147483647)) { + if (jj_2_148(2)) { + jj_consume_token(TABLE); + } else { + ; + } + table = CompoundIdentifier(); + if (jj_2_149(2)) { + column = SimpleIdentifier(); + } else { + E(); + column = null; + } + {if (true) return new SqlDescribeTable(s.add(table).addIf(column).pos(), + table, column);} + } else if (jj_2_152(2)) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STATEMENT: + jj_consume_token(STATEMENT); + break; + default: + jj_la1[0] = jj_gen; + ; + } + stmt = SqlQueryOrDml(); + // DESCRIBE STATEMENT currently does the same as EXPLAIN. See + // [CALCITE-1221] Implement DESCRIBE DATABASE, CATALOG, STATEMENT + final SqlExplainLevel detailLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES; + final SqlExplain.Depth depth = SqlExplain.Depth.PHYSICAL; + final SqlExplainFormat format = SqlExplainFormat.TEXT; + {if (true) return new SqlExplain(s.end(stmt), + stmt, + detailLevel.symbol(SqlParserPos.ZERO), + depth.symbol(SqlParserPos.ZERO), + format.symbol(SqlParserPos.ZERO), + nDynamicParams);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a CALL statement. + */ + final public SqlNode SqlProcedureCall() throws ParseException { + final Span s; + SqlNode routineCall; + jj_consume_token(CALL); + s = span(); + routineCall = NamedRoutineCall(SqlFunctionCategory.USER_DEFINED_PROCEDURE, + ExprContext.ACCEPT_SUB_QUERY); + {if (true) return SqlStdOperatorTable.PROCEDURE_CALL.createCall( + s.end(routineCall), routineCall);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode NamedRoutineCall(SqlFunctionCategory routineType, + ExprContext exprContext) throws ParseException { + SqlIdentifier name; + final List list = new ArrayList(); + final Span s; + name = CompoundIdentifier(); + s = span(); + jj_consume_token(LPAREN); + if (jj_2_154(2)) { + Arg0(list, exprContext); + label_13: + while (true) { + if (jj_2_153(2)) { + ; + } else { + break label_13; + } + jj_consume_token(COMMA); + // a comma-list can't appear where only a query is expected + checkNonQueryExpression(exprContext); + Arg(list, exprContext); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return createCall(name, s.end(this), routineType, null, list);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an INSERT statement. + */ + final public SqlNode SqlInsert() throws ParseException { + final List keywords = new ArrayList(); + final SqlNodeList keywordList; + SqlNode table; + SqlNodeList extendList = null; + SqlNode source; + SqlNodeList columnList = null; + final Span s; + if (jj_2_155(2)) { + jj_consume_token(INSERT); + } else if (jj_2_156(2)) { + jj_consume_token(UPSERT); + keywords.add(SqlInsertKeyword.UPSERT.symbol(getPos())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + SqlInsertKeywords(keywords); + keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos()); + jj_consume_token(INTO); + table = TableRefWithHintsOpt(); + if (jj_2_158(5)) { + if (jj_2_157(2)) { + jj_consume_token(EXTEND); + } else { + ; + } + extendList = ExtendList(); + table = extend(table, extendList); + } else { + ; + } + if (jj_2_159(2)) { + final Pair p; + p = ParenthesizedCompoundIdentifierList(); + if (p.right.size() > 0) { + table = extend(table, p.right); + } + if (p.left.size() > 0) { + columnList = p.left; + } + } else { + ; + } + source = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY); + {if (true) return new SqlInsert(s.end(source), keywordList, table, source, + columnList);} + throw new Error("Missing return statement in function"); + } + +/* + * Abstract production: + * + * void SqlInsertKeywords(List keywords) + * + * Parses dialect-specific keywords immediately following the INSERT keyword. + */ + +/** + * Parses a DELETE statement. + */ + final public SqlNode SqlDelete() throws ParseException { + SqlNode table; + SqlNodeList extendList = null; + SqlIdentifier alias = null; + final SqlNode condition; + final Span s; + jj_consume_token(DELETE); + s = span(); + jj_consume_token(FROM); + table = TableRefWithHintsOpt(); + if (jj_2_161(2)) { + if (jj_2_160(2)) { + jj_consume_token(EXTEND); + } else { + ; + } + extendList = ExtendList(); + table = extend(table, extendList); + } else { + ; + } + if (jj_2_163(2)) { + if (jj_2_162(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + } else { + ; + } + condition = WhereOpt(); + {if (true) return new SqlDelete(s.add(table).addIf(extendList).addIf(alias) + .addIf(condition).pos(), table, condition, null, alias);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an UPDATE statement. + */ + final public SqlNode SqlUpdate() throws ParseException { + SqlNode table; + SqlNodeList extendList = null; + SqlIdentifier alias = null; + SqlNode condition; + SqlNodeList sourceExpressionList; + SqlNodeList targetColumnList; + SqlIdentifier id; + SqlNode exp; + final Span s; + jj_consume_token(UPDATE); + s = span(); + table = TableRefWithHintsOpt(); + targetColumnList = new SqlNodeList(s.pos()); + sourceExpressionList = new SqlNodeList(s.pos()); + if (jj_2_165(2)) { + if (jj_2_164(2)) { + jj_consume_token(EXTEND); + } else { + ; + } + extendList = ExtendList(); + table = extend(table, extendList); + } else { + ; + } + if (jj_2_167(2)) { + if (jj_2_166(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + } else { + ; + } + jj_consume_token(SET); + id = SimpleIdentifier(); + targetColumnList.add(id); + jj_consume_token(EQ); + exp = Expression(ExprContext.ACCEPT_SUB_QUERY); + // TODO: support DEFAULT also + sourceExpressionList.add(exp); + label_14: + while (true) { + if (jj_2_168(2)) { + ; + } else { + break label_14; + } + jj_consume_token(COMMA); + id = SimpleIdentifier(); + targetColumnList.add(id); + jj_consume_token(EQ); + exp = Expression(ExprContext.ACCEPT_SUB_QUERY); + sourceExpressionList.add(exp); + } + condition = WhereOpt(); + {if (true) return new SqlUpdate(s.addAll(targetColumnList) + .addAll(sourceExpressionList).addIf(condition).pos(), table, + targetColumnList, sourceExpressionList, condition, null, alias);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a MERGE statement. + */ + final public SqlNode SqlMerge() throws ParseException { + SqlNode table; + SqlNodeList extendList = null; + SqlIdentifier alias = null; + SqlNode sourceTableRef; + SqlNode condition; + SqlUpdate updateCall = null; + SqlInsert insertCall = null; + final Span s; + jj_consume_token(MERGE); + s = span(); + jj_consume_token(INTO); + table = TableRefWithHintsOpt(); + if (jj_2_170(2)) { + if (jj_2_169(2)) { + jj_consume_token(EXTEND); + } else { + ; + } + extendList = ExtendList(); + table = extend(table, extendList); + } else { + ; + } + if (jj_2_172(2)) { + if (jj_2_171(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + } else { + ; + } + jj_consume_token(USING); + sourceTableRef = TableRef(); + jj_consume_token(ON); + condition = Expression(ExprContext.ACCEPT_SUB_QUERY); + if (jj_2_174(2)) { + updateCall = WhenMatchedClause(table, alias); + if (jj_2_173(2)) { + insertCall = WhenNotMatchedClause(table); + } else { + ; + } + } else if (jj_2_175(2)) { + insertCall = WhenNotMatchedClause(table); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlMerge(s.addIf(updateCall).addIf(insertCall).pos(), table, + condition, sourceTableRef, updateCall, insertCall, null, alias);} + throw new Error("Missing return statement in function"); + } + + final public SqlUpdate WhenMatchedClause(SqlNode table, SqlIdentifier alias) throws ParseException { + SqlIdentifier id; + final Span s; + final SqlNodeList updateColumnList = new SqlNodeList(SqlParserPos.ZERO); + SqlNode exp; + final SqlNodeList updateExprList = new SqlNodeList(SqlParserPos.ZERO); + jj_consume_token(WHEN); + s = span(); + jj_consume_token(MATCHED); + jj_consume_token(THEN); + jj_consume_token(UPDATE); + jj_consume_token(SET); + id = CompoundIdentifier(); + updateColumnList.add(id); + jj_consume_token(EQ); + exp = Expression(ExprContext.ACCEPT_SUB_QUERY); + updateExprList.add(exp); + label_15: + while (true) { + if (jj_2_176(2)) { + ; + } else { + break label_15; + } + jj_consume_token(COMMA); + id = CompoundIdentifier(); + updateColumnList.add(id); + jj_consume_token(EQ); + exp = Expression(ExprContext.ACCEPT_SUB_QUERY); + updateExprList.add(exp); + } + {if (true) return new SqlUpdate(s.addAll(updateExprList).pos(), table, + updateColumnList, updateExprList, null, null, alias);} + throw new Error("Missing return statement in function"); + } + + final public SqlInsert WhenNotMatchedClause(SqlNode table) throws ParseException { + final Span insertSpan, valuesSpan; + final List keywords = new ArrayList(); + final SqlNodeList keywordList; + SqlNodeList insertColumnList = null; + SqlNode rowConstructor; + SqlNode insertValues; + jj_consume_token(WHEN); + jj_consume_token(NOT); + jj_consume_token(MATCHED); + jj_consume_token(THEN); + jj_consume_token(INSERT); + insertSpan = span(); + SqlInsertKeywords(keywords); + keywordList = new SqlNodeList(keywords, insertSpan.end(this)); + if (jj_2_177(2)) { + insertColumnList = ParenthesizedSimpleIdentifierList(); + } else { + ; + } + if (jj_2_178(2)) { + jj_consume_token(LPAREN); + } else { + ; + } + jj_consume_token(VALUES); + valuesSpan = span(); + rowConstructor = RowConstructor(); + if (jj_2_179(2)) { + jj_consume_token(RPAREN); + } else { + ; + } + // TODO zfong 5/26/06: note that extra parentheses are accepted above + // around the VALUES clause as a hack for unparse, but this is + // actually invalid SQL; should fix unparse + insertValues = SqlStdOperatorTable.VALUES.createCall( + valuesSpan.end(this), rowConstructor); + {if (true) return new SqlInsert(insertSpan.end(this), keywordList, + table, insertValues, insertColumnList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses the select list of a SELECT statement. + */ + final public List SelectList() throws ParseException { + final List list = new ArrayList(); + SqlNode item; + item = SelectItem(); + list.add(item); + label_16: + while (true) { + if (jj_2_180(2)) { + ; + } else { + break label_16; + } + jj_consume_token(COMMA); + item = SelectItem(); + list.add(item); + } + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses one item in a select list. + */ + final public SqlNode SelectItem() throws ParseException { + SqlNode e; + final SqlIdentifier id; + e = SelectExpression(); + if (jj_2_183(2)) { + if (jj_2_181(2)) { + jj_consume_token(AS); + } else { + ; + } + if (jj_2_182(2)) { + id = SimpleIdentifier(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUOTED_STRING: + id = SimpleIdentifierFromStringLiteral(); + break; + default: + jj_la1[1] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + e = SqlStdOperatorTable.AS.createCall(span().end(e), e, id); + } else { + ; + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses one unaliased expression in a select list. + */ + final public SqlNode SelectExpression() throws ParseException { + SqlNode e; + if (jj_2_184(2)) { + jj_consume_token(STAR); + {if (true) return SqlIdentifier.star(getPos());} + } else if (jj_2_185(2)) { + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return e;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlLiteral Natural() throws ParseException { + if (jj_2_186(2)) { + jj_consume_token(NATURAL); + {if (true) return SqlLiteral.createBoolean(true, getPos());} + } else { + {if (true) return SqlLiteral.createBoolean(false, getPos());} + } + throw new Error("Missing return statement in function"); + } + + final public SqlLiteral JoinType() throws ParseException { + JoinType joinType; + if (jj_2_190(3)) { + jj_consume_token(JOIN); + joinType = JoinType.INNER; + } else if (jj_2_191(2)) { + jj_consume_token(INNER); + jj_consume_token(JOIN); + joinType = JoinType.INNER; + } else if (jj_2_192(2)) { + jj_consume_token(LEFT); + if (jj_2_187(2)) { + jj_consume_token(OUTER); + } else { + ; + } + jj_consume_token(JOIN); + joinType = JoinType.LEFT; + } else if (jj_2_193(2)) { + jj_consume_token(RIGHT); + if (jj_2_188(2)) { + jj_consume_token(OUTER); + } else { + ; + } + jj_consume_token(JOIN); + joinType = JoinType.RIGHT; + } else if (jj_2_194(2)) { + jj_consume_token(FULL); + if (jj_2_189(2)) { + jj_consume_token(OUTER); + } else { + ; + } + jj_consume_token(JOIN); + joinType = JoinType.FULL; + } else if (jj_2_195(2)) { + jj_consume_token(CROSS); + jj_consume_token(JOIN); + joinType = JoinType.CROSS; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return joinType.symbol(getPos());} + throw new Error("Missing return statement in function"); + } + +/** Matches "LEFT JOIN t ON ...", "RIGHT JOIN t USING ...", "JOIN t". */ + final public SqlNode JoinTable(SqlNode e) throws ParseException { + SqlNode e2, condition; + final SqlLiteral natural, joinType, on, using; + SqlNodeList list; + natural = Natural(); + joinType = JoinType(); + e2 = TableRef(); + if (jj_2_196(2)) { + jj_consume_token(ON); + on = JoinConditionType.ON.symbol(getPos()); + condition = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + on, + condition);} + } else if (jj_2_197(2)) { + jj_consume_token(USING); + using = JoinConditionType.USING.symbol(getPos()); + list = ParenthesizedSimpleIdentifierList(); + {if (true) return new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + using, + new SqlNodeList(list, Span.of(using).end(this)));} + } else { + {if (true) return new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + JoinConditionType.NONE.symbol(joinType.getParserPosition()), + null);} + } + throw new Error("Missing return statement in function"); + } + +// TODO jvs 15-Nov-2003: SQL standard allows parentheses in the FROM list for +// building up non-linear join trees (e.g. OUTER JOIN two tables, and then INNER +// JOIN the result). Also note that aliases on parenthesized FROM expressions +// "hide" all table names inside the parentheses (without aliases, they're +// visible). +// +// We allow CROSS JOIN to have a join condition, even though that is not valid +// SQL; the validator will catch it. +/** + * Parses the FROM clause for a SELECT. + * + *

FROM is mandatory in standard SQL, optional in dialects such as MySQL, + * PostgreSQL. The parser allows SELECT without FROM, but the validator fails + * if conformance is, say, STRICT_2003. + */ + final public SqlNode FromClause() throws ParseException { + SqlNode e, e2, condition; + SqlLiteral natural, joinType, joinConditionType; + SqlNodeList list; + SqlParserPos pos; + e = TableRef(); + label_17: + while (true) { + if (jj_2_198(2)) { + ; + } else { + break label_17; + } + if (jj_2_201(3)) { + natural = Natural(); + joinType = JoinType(); + e2 = TableRef(); + if (jj_2_199(2)) { + jj_consume_token(ON); + joinConditionType = JoinConditionType.ON.symbol(getPos()); + condition = Expression(ExprContext.ACCEPT_SUB_QUERY); + e = new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + joinConditionType, + condition); + } else if (jj_2_200(2)) { + jj_consume_token(USING); + joinConditionType = JoinConditionType.USING.symbol(getPos()); + list = ParenthesizedSimpleIdentifierList(); + e = new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + joinConditionType, + new SqlNodeList(list.getList(), Span.of(joinConditionType).end(this))); + } else { + e = new SqlJoin(joinType.getParserPosition(), + e, + natural, + joinType, + e2, + JoinConditionType.NONE.symbol(joinType.getParserPosition()), + null); + } + } else if (jj_2_202(2)) { + jj_consume_token(COMMA); + joinType = JoinType.COMMA.symbol(getPos()); + e2 = TableRef(); + e = new SqlJoin(joinType.getParserPosition(), + e, + SqlLiteral.createBoolean(false, joinType.getParserPosition()), + joinType, + e2, + JoinConditionType.NONE.symbol(SqlParserPos.ZERO), + null); + } else if (jj_2_203(2)) { + jj_consume_token(CROSS); + joinType = JoinType.CROSS.symbol(getPos()); + jj_consume_token(APPLY); + e2 = TableRef2(true); + if (!this.conformance.isApplyAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());} + } + e = new SqlJoin(joinType.getParserPosition(), + e, + SqlLiteral.createBoolean(false, joinType.getParserPosition()), + joinType, + e2, + JoinConditionType.NONE.symbol(SqlParserPos.ZERO), + null); + } else if (jj_2_204(2)) { + jj_consume_token(OUTER); + joinType = JoinType.LEFT.symbol(getPos()); + jj_consume_token(APPLY); + e2 = TableRef2(true); + if (!this.conformance.isApplyAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());} + } + e = new SqlJoin(joinType.getParserPosition(), + e, + SqlLiteral.createBoolean(false, joinType.getParserPosition()), + joinType, + e2, + JoinConditionType.ON.symbol(SqlParserPos.ZERO), + SqlLiteral.createBoolean(true, joinType.getParserPosition())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a table reference in a FROM clause, not lateral unless LATERAL + * is explicitly specified. + */ + final public SqlNode TableRef() throws ParseException { + final SqlNode e; + e = TableRef2(false); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a table reference in a FROM clause. + */ + final public SqlNode TableRef2(boolean lateral) throws ParseException { + SqlNode tableRef; + final SqlNode over; + final SqlNode snapshot; + final SqlNode match; + SqlNodeList extendList = null; + final SqlIdentifier alias; + final Span s, s2; + SqlNodeList args; + SqlNode sample; + boolean isBernoulli; + SqlNumericLiteral samplePercentage; + boolean isRepeatable = false; + int repeatableSeed = 0; + SqlNodeList columnAliasList = null; + SqlUnnestOperator unnestOp = SqlStdOperatorTable.UNNEST; + if (jj_2_213(2)) { + tableRef = TableRefWithHintsOpt(); + if (jj_2_206(2)) { + if (jj_2_205(2)) { + jj_consume_token(EXTEND); + } else { + ; + } + extendList = ExtendList(); + tableRef = extend(tableRef, extendList); + } else { + ; + } + over = TableOverOpt(); + if (over != null) { + tableRef = SqlStdOperatorTable.OVER.createCall( + getPos(), tableRef, over); + } + if (jj_2_207(2)) { + tableRef = Snapshot(tableRef); + } else { + ; + } + if (jj_2_208(2)) { + tableRef = MatchRecognize(tableRef); + } else { + ; + } + } else if (jj_2_214(2)) { + if (jj_2_209(2)) { + jj_consume_token(LATERAL); + lateral = true; + } else { + ; + } + tableRef = ParenthesizedExpression(ExprContext.ACCEPT_QUERY); + over = TableOverOpt(); + if (over != null) { + tableRef = SqlStdOperatorTable.OVER.createCall( + getPos(), tableRef, over); + } + if (lateral) { + tableRef = SqlStdOperatorTable.LATERAL.createCall( + getPos(), tableRef); + } + if (jj_2_210(2)) { + tableRef = MatchRecognize(tableRef); + } else { + ; + } + } else if (jj_2_215(2)) { + jj_consume_token(UNNEST); + s = span(); + args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY); + if (jj_2_211(2)) { + jj_consume_token(WITH); + jj_consume_token(ORDINALITY); + unnestOp = SqlStdOperatorTable.UNNEST_WITH_ORDINALITY; + } else { + ; + } + tableRef = unnestOp.createCall(s.end(this), (List) args); + } else if (jj_2_216(2)) { + if (jj_2_212(2)) { + jj_consume_token(LATERAL); + lateral = true; + } else { + ; + } + jj_consume_token(TABLE); + s = span(); + jj_consume_token(LPAREN); + tableRef = TableFunctionCall(s.pos()); + jj_consume_token(RPAREN); + if (lateral) { + tableRef = SqlStdOperatorTable.LATERAL.createCall( + s.end(this), tableRef); + } + } else if (jj_2_217(2)) { + tableRef = ExtendedTableRef(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_218(2)) { + tableRef = Pivot(tableRef); + } else { + ; + } + if (jj_2_219(2)) { + tableRef = Unpivot(tableRef); + } else { + ; + } + if (jj_2_222(2)) { + if (jj_2_220(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + if (jj_2_221(2)) { + columnAliasList = ParenthesizedSimpleIdentifierList(); + } else { + ; + } + if (columnAliasList == null) { + tableRef = SqlStdOperatorTable.AS.createCall( + Span.of(tableRef).end(this), tableRef, alias); + } else { + List idList = new ArrayList(); + idList.add(tableRef); + idList.add(alias); + idList.addAll(columnAliasList.getList()); + tableRef = SqlStdOperatorTable.AS.createCall( + Span.of(tableRef).end(this), idList); + } + } else { + ; + } + if (jj_2_228(2)) { + jj_consume_token(TABLESAMPLE); + s2 = span(); + if (jj_2_226(2)) { + jj_consume_token(SUBSTITUTE); + jj_consume_token(LPAREN); + sample = StringLiteral(); + jj_consume_token(RPAREN); + String sampleName = + SqlLiteral.unchain(sample).getValueAs(String.class); + SqlSampleSpec sampleSpec = SqlSampleSpec.createNamed(sampleName); + final SqlLiteral sampleLiteral = + SqlLiteral.createSample(sampleSpec, s2.end(this)); + tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall( + s2.add(tableRef).end(this), tableRef, sampleLiteral); + } else if (jj_2_227(2)) { + if (jj_2_223(2)) { + jj_consume_token(BERNOULLI); + isBernoulli = true; + } else if (jj_2_224(2)) { + jj_consume_token(SYSTEM); + isBernoulli = false; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(LPAREN); + samplePercentage = UnsignedNumericLiteral(); + jj_consume_token(RPAREN); + if (jj_2_225(2)) { + jj_consume_token(REPEATABLE); + jj_consume_token(LPAREN); + repeatableSeed = IntLiteral(); + jj_consume_token(RPAREN); + isRepeatable = true; + } else { + ; + } + final BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100L); + BigDecimal rate = samplePercentage.bigDecimalValue(); + if (rate.compareTo(BigDecimal.ZERO) < 0 + || rate.compareTo(ONE_HUNDRED) > 0) + { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.invalidSampleSize());} + } + + // Treat TABLESAMPLE(0) and TABLESAMPLE(100) as no table + // sampling at all. Not strictly correct: TABLESAMPLE(0) + // should produce no output, but it simplifies implementation + // to know that some amount of sampling will occur. + // In practice values less than ~1E-43% are treated as 0.0 and + // values greater than ~99.999997% are treated as 1.0 + float fRate = rate.divide(ONE_HUNDRED).floatValue(); + if (fRate > 0.0f && fRate < 1.0f) { + SqlSampleSpec tableSampleSpec = + isRepeatable + ? SqlSampleSpec.createTableSample( + isBernoulli, fRate, repeatableSeed) + : SqlSampleSpec.createTableSample(isBernoulli, fRate); + + SqlLiteral tableSampleLiteral = + SqlLiteral.createSample(tableSampleSpec, s2.end(this)); + tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall( + s2.end(this), tableRef, tableSampleLiteral); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return tableRef;} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList ExtendList() throws ParseException { + final Span s; + List list = new ArrayList(); + jj_consume_token(LPAREN); + s = span(); + ColumnType(list); + label_18: + while (true) { + if (jj_2_229(2)) { + ; + } else { + break label_18; + } + jj_consume_token(COMMA); + ColumnType(list); + } + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public void ColumnType(List list) throws ParseException { + SqlIdentifier name; + SqlDataTypeSpec type; + boolean nullable = true; + name = CompoundIdentifier(); + type = DataType(); + if (jj_2_230(2)) { + jj_consume_token(NOT); + jj_consume_token(NULL); + nullable = false; + } else { + ; + } + list.add(name); + list.add(type.withNullable(nullable, getPos())); + } + +/** + * Parses a compound identifier with optional type. + */ + final public void CompoundIdentifierType(List list, List extendList) throws ParseException { + final SqlIdentifier name; + SqlDataTypeSpec type = null; + boolean nullable = true; + name = CompoundIdentifier(); + if (jj_2_232(2)) { + type = DataType(); + if (jj_2_231(2)) { + jj_consume_token(NOT); + jj_consume_token(NULL); + nullable = false; + } else { + ; + } + } else { + ; + } + if (type != null) { + if (!this.conformance.allowExtend()) { + {if (true) throw SqlUtil.newContextException(type.getParserPosition(), + RESOURCE.extendNotAllowed());} + } + extendList.add(name); + extendList.add(type.withNullable(nullable, getPos())); + } + list.add(name); + } + + final public SqlNode TableFunctionCall(SqlParserPos pos) throws ParseException { + SqlNode call; + SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION; + if (jj_2_233(2)) { + jj_consume_token(SPECIFIC); + funcType = SqlFunctionCategory.USER_DEFINED_TABLE_SPECIFIC_FUNCTION; + } else { + ; + } + call = NamedRoutineCall(funcType, ExprContext.ACCEPT_CURSOR); + {if (true) return SqlStdOperatorTable.COLLECTION_TABLE.createCall(pos, call);} + throw new Error("Missing return statement in function"); + } + +/** + * Abstract production: + * SqlNode ExtendedTableRef() + * + *

Allows parser to be extended with new types of table references. The + * default implementation of this production is empty. + */ + +/* + * Abstract production: + * + * SqlNode TableOverOpt() + * + * Allows an OVER clause following a table expression as an extension to + * standard SQL syntax. The default implementation of this production is empty. + */ + +/** + * Parses an explicit TABLE t reference. + */ + final public SqlNode ExplicitTable(SqlParserPos pos) throws ParseException { + SqlNode tableRef; + jj_consume_token(TABLE); + tableRef = CompoundIdentifier(); + {if (true) return SqlStdOperatorTable.EXPLICIT_TABLE.createCall(pos, tableRef);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a VALUES leaf query expression. + */ + final public SqlNode TableConstructor() throws ParseException { + final List rowConstructorList = new ArrayList(); + final Span s; + jj_consume_token(VALUES); + s = span(); + RowConstructorList(rowConstructorList); + {if (true) return SqlStdOperatorTable.VALUES.createCall( + s.end(this), rowConstructorList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses one or more rows in a VALUES expression. + */ + final public void RowConstructorList(List list) throws ParseException { + SqlNode rowConstructor; + rowConstructor = RowConstructor(); + list.add(rowConstructor); + label_19: + while (true) { + if (jj_2_234(2)) { + ; + } else { + break label_19; + } + jj_consume_token(COMMA); + rowConstructor = RowConstructor(); + list.add(rowConstructor); + } + } + +/** + * Parses a row constructor in the context of a VALUES expression. + */ + final public SqlNode RowConstructor() throws ParseException { + SqlNodeList valueList; + SqlNode value; + final Span s; + if (jj_2_236(3)) { + jj_consume_token(LPAREN); + s = span(); + jj_consume_token(ROW); + valueList = ParenthesizedQueryOrCommaListWithDefault(ExprContext.ACCEPT_NONCURSOR); + jj_consume_token(RPAREN); + s.add(this); + } else if (jj_2_237(3)) { + if (jj_2_235(2)) { + jj_consume_token(ROW); + s = span(); + } else { + s = Span.of(); + } + valueList = ParenthesizedQueryOrCommaListWithDefault(ExprContext.ACCEPT_NONCURSOR); + } else if (jj_2_238(2)) { + value = Expression(ExprContext.ACCEPT_NONCURSOR); + // NOTE: A bare value here is standard SQL syntax, believe it or + // not. Taken together with multi-row table constructors, it leads + // to very easy mistakes if you forget the parentheses on a + // single-row constructor. This is also the reason for the + // LOOKAHEAD in RowConstructorList(). It would be so much more + // reasonable to require parentheses. Sigh. + s = Span.of(value); + valueList = new SqlNodeList(Collections.singletonList(value), + value.getParserPosition()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + // REVIEW jvs 8-Feb-2004: Should we discriminate between scalar + // sub-queries inside of ROW and row sub-queries? The standard does, + // but the distinction seems to be purely syntactic. + {if (true) return SqlStdOperatorTable.ROW.createCall(s.end(valueList), + (List) valueList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses the optional WHERE clause for SELECT, DELETE, and UPDATE. + */ + final public SqlNode WhereOpt() throws ParseException { + SqlNode condition; + if (jj_2_239(2)) { + jj_consume_token(WHERE); + condition = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return condition;} + } else { + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses the optional GROUP BY clause for SELECT. + */ + final public SqlNodeList GroupByOpt() throws ParseException { + List list = new ArrayList(); + final Span s; + if (jj_2_240(2)) { + jj_consume_token(GROUP); + s = span(); + jj_consume_token(BY); + list = GroupingElementList(); + {if (true) return new SqlNodeList(list, s.addAll(list).pos());} + } else { + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public List GroupingElementList() throws ParseException { + List list = new ArrayList(); + SqlNode e; + e = GroupingElement(); + list.add(e); + label_20: + while (true) { + if (jj_2_241(2)) { + ; + } else { + break label_20; + } + jj_consume_token(COMMA); + e = GroupingElement(); + list.add(e); + } + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode GroupingElement() throws ParseException { + List list; + final SqlNodeList nodes; + final SqlNode e; + final Span s; + if (jj_2_242(2)) { + jj_consume_token(GROUPING); + s = span(); + jj_consume_token(SETS); + jj_consume_token(LPAREN); + list = GroupingElementList(); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.GROUPING_SETS.createCall(s.end(this), list);} + } else if (jj_2_243(2)) { + jj_consume_token(ROLLUP); + s = span(); + jj_consume_token(LPAREN); + nodes = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.ROLLUP.createCall(s.end(this), + nodes.getList());} + } else if (jj_2_244(2)) { + jj_consume_token(CUBE); + s = span(); + jj_consume_token(LPAREN); + nodes = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.CUBE.createCall(s.end(this), + nodes.getList());} + } else if (jj_2_245(3)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(getPos());} + } else if (jj_2_246(2)) { + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return e;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a list of expressions separated by commas. + */ + final public SqlNodeList ExpressionCommaList(final Span s, + ExprContext exprContext) throws ParseException { + final List list = new ArrayList(); + ExpressionCommaList2(list, exprContext); + {if (true) return new SqlNodeList(list, s.addAll(list).pos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a list of expressions separated by commas, + * appending expressions to a given list. + */ + final public void ExpressionCommaList2(List list, ExprContext exprContext) throws ParseException { + SqlNode e; + e = Expression(exprContext); + list.add(e); + label_21: + while (true) { + if (jj_2_247(2)) { + ; + } else { + break label_21; + } + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + list.add(e); + } + } + +/** + * Parses the optional HAVING clause for SELECT. + */ + final public SqlNode HavingOpt() throws ParseException { + SqlNode e; + if (jj_2_248(2)) { + jj_consume_token(HAVING); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return e;} + } else { + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses the optional WINDOW clause for SELECT + */ + final public SqlNodeList WindowOpt() throws ParseException { + SqlIdentifier id; + SqlWindow e; + List list; + final Span s; + if (jj_2_250(2)) { + jj_consume_token(WINDOW); + s = span(); + id = SimpleIdentifier(); + jj_consume_token(AS); + e = WindowSpecification(); + e.setDeclName(id); + list = startList(e); + label_22: + while (true) { + if (jj_2_249(2)) { + ; + } else { + break label_22; + } + jj_consume_token(COMMA); + id = SimpleIdentifier(); + jj_consume_token(AS); + e = WindowSpecification(); + e.setDeclName(id); + list.add(e); + } + {if (true) return new SqlNodeList(list, s.addAll(list).pos());} + } else { + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a window specification. + */ + final public SqlWindow WindowSpecification() throws ParseException { + SqlIdentifier id; + List list; + SqlNodeList partitionList; + SqlNodeList orderList; + SqlLiteral isRows = SqlLiteral.createBoolean(false, SqlParserPos.ZERO); + SqlNode lowerBound = null, upperBound = null; + SqlParserPos startPos; + final Span s, s1, s2; + SqlLiteral allowPartial = null; + jj_consume_token(LPAREN); + s = span(); + if (jj_2_251(2)) { + id = SimpleIdentifier(); + } else { + id = null; + } + if (jj_2_252(2)) { + jj_consume_token(PARTITION); + s1 = span(); + jj_consume_token(BY); + partitionList = ExpressionCommaList(s1, ExprContext.ACCEPT_NON_QUERY); + } else { + partitionList = SqlNodeList.EMPTY; + } + if (jj_2_253(2)) { + orderList = OrderBy(true); + } else { + orderList = SqlNodeList.EMPTY; + } + if (jj_2_258(2)) { + if (jj_2_254(2)) { + jj_consume_token(ROWS); + isRows = SqlLiteral.createBoolean(true, getPos()); + } else if (jj_2_255(2)) { + jj_consume_token(RANGE); + isRows = SqlLiteral.createBoolean(false, getPos()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_256(2)) { + jj_consume_token(BETWEEN); + lowerBound = WindowRange(); + jj_consume_token(AND); + upperBound = WindowRange(); + } else if (jj_2_257(2)) { + lowerBound = WindowRange(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + if (jj_2_261(2)) { + if (jj_2_259(2)) { + jj_consume_token(ALLOW); + s2 = span(); + jj_consume_token(PARTIAL); + allowPartial = SqlLiteral.createBoolean(true, s2.end(this)); + } else if (jj_2_260(2)) { + jj_consume_token(DISALLOW); + s2 = span(); + jj_consume_token(PARTIAL); + allowPartial = SqlLiteral.createBoolean(false, s2.end(this)); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlWindow.create( + null, id, partitionList, orderList, + isRows, lowerBound, upperBound, allowPartial, s.end(this));} + throw new Error("Missing return statement in function"); + } + + final public SqlNode WindowRange() throws ParseException { + final SqlNode e; + final Span s; + if (jj_2_266(2)) { + jj_consume_token(CURRENT); + s = span(); + jj_consume_token(ROW); + {if (true) return SqlWindow.createCurrentRow(s.end(this));} + } else if (jj_2_267(2)) { + jj_consume_token(UNBOUNDED); + s = span(); + if (jj_2_262(2)) { + jj_consume_token(PRECEDING); + {if (true) return SqlWindow.createUnboundedPreceding(s.end(this));} + } else if (jj_2_263(2)) { + jj_consume_token(FOLLOWING); + {if (true) return SqlWindow.createUnboundedFollowing(s.end(this));} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_268(2)) { + e = Expression(ExprContext.ACCEPT_NON_QUERY); + if (jj_2_264(2)) { + jj_consume_token(PRECEDING); + {if (true) return SqlWindow.createPreceding(e, getPos());} + } else if (jj_2_265(2)) { + jj_consume_token(FOLLOWING); + {if (true) return SqlWindow.createFollowing(e, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses an ORDER BY clause. + */ + final public SqlNodeList OrderBy(boolean accept) throws ParseException { + List list; + SqlNode e; + final Span s; + jj_consume_token(ORDER); + s = span(); + if (!accept) { + // Someone told us ORDER BY wasn't allowed here. So why + // did they bother calling us? To get the correct + // parser position for error reporting. + {if (true) throw SqlUtil.newContextException(s.pos(), RESOURCE.illegalOrderBy());} + } + jj_consume_token(BY); + e = OrderItem(); + list = startList(e); + label_23: + while (true) { + if (jj_2_269(2)) { + ; + } else { + break label_23; + } + jj_consume_token(COMMA); + e = OrderItem(); + list.add(e); + } + {if (true) return new SqlNodeList(list, s.addAll(list).pos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses one list item in an ORDER BY clause. + */ + final public SqlNode OrderItem() throws ParseException { + SqlNode e; + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + if (jj_2_272(2)) { + if (jj_2_270(2)) { + jj_consume_token(ASC); + } else if (jj_2_271(2)) { + jj_consume_token(DESC); + e = SqlStdOperatorTable.DESC.createCall(getPos(), e); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + if (jj_2_275(2)) { + if (jj_2_273(2)) { + jj_consume_token(NULLS); + jj_consume_token(FIRST); + e = SqlStdOperatorTable.NULLS_FIRST.createCall(getPos(), e); + } else if (jj_2_274(2)) { + jj_consume_token(NULLS); + jj_consume_token(LAST); + e = SqlStdOperatorTable.NULLS_LAST.createCall(getPos(), e); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a FOR SYSTEM_TIME clause following a table expression. + */ + final public SqlSnapshot Snapshot(SqlNode tableRef) throws ParseException { + final Span s; + final SqlNode e; + s = span(); + jj_consume_token(FOR); + jj_consume_token(SYSTEM_TIME); + jj_consume_token(AS); + jj_consume_token(OF); + // Syntax for temporal table in + // standard SQL 2011 IWD 9075-2:201?(E) 7.6 + // supports grammar as following: + // 1. datetime literal + // 2. datetime value function, i.e. CURRENT_TIMESTAMP + // 3. datetime term in 1 or 2 +(or -) interval term + + // We extend to support column reference, use Expression + // to simplify the parsing code. + e = Expression(ExprContext.ACCEPT_NON_QUERY); + {if (true) return new SqlSnapshot(s.end(this), tableRef, e);} + throw new Error("Missing return statement in function"); + } + +/** Parses a PIVOT clause following a table expression. */ + final public SqlNode Pivot(SqlNode tableRef) throws ParseException { + final Span s; + final Span s2; + final List aggList = new ArrayList(); + final List valueList = new ArrayList(); + final SqlNodeList axisList; + final SqlNodeList inList; + jj_consume_token(PIVOT); + s = span(); + jj_consume_token(LPAREN); + PivotAgg(aggList); + label_24: + while (true) { + if (jj_2_276(2)) { + ; + } else { + break label_24; + } + jj_consume_token(COMMA); + PivotAgg(aggList); + } + jj_consume_token(FOR); + axisList = SimpleIdentifierOrList(); + jj_consume_token(IN); + jj_consume_token(LPAREN); + s2 = span(); + if (jj_2_278(2)) { + PivotValue(valueList); + label_25: + while (true) { + if (jj_2_277(2)) { + ; + } else { + break label_25; + } + jj_consume_token(COMMA); + PivotValue(valueList); + } + } else { + ; + } + jj_consume_token(RPAREN); + inList = new SqlNodeList(valueList, s2.end(this)); + jj_consume_token(RPAREN); + {if (true) return new SqlPivot(s.end(this), tableRef, + new SqlNodeList(aggList, SqlParserPos.sum(aggList)), + axisList, inList);} + throw new Error("Missing return statement in function"); + } + + final public void PivotAgg(List list) throws ParseException { + final SqlNode e; + final SqlIdentifier alias; + e = NamedFunctionCall(); + if (jj_2_280(2)) { + if (jj_2_279(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + list.add( + SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e, + alias)); + } else { + list.add(e); + } + } + + final public void PivotValue(List list) throws ParseException { + final SqlNode e; + final SqlNodeList tuple; + final SqlIdentifier alias; + e = RowConstructor(); + tuple = SqlParserUtil.stripRow(e); + if (jj_2_282(2)) { + if (jj_2_281(2)) { + jj_consume_token(AS); + } else { + ; + } + alias = SimpleIdentifier(); + list.add( + SqlStdOperatorTable.AS.createCall(Span.of(tuple).end(this), + tuple, alias)); + } else { + list.add(tuple); + } + } + +/** Parses an UNPIVOT clause following a table expression. */ + final public SqlNode Unpivot(SqlNode tableRef) throws ParseException { + final Span s; + final boolean includeNulls; + final SqlNodeList measureList; + final SqlNodeList axisList; + final Span s2; + final List values = new ArrayList(); + final SqlNodeList inList; + jj_consume_token(UNPIVOT); + s = span(); + if (jj_2_283(2)) { + jj_consume_token(INCLUDE); + jj_consume_token(NULLS); + includeNulls = true; + } else if (jj_2_284(2)) { + jj_consume_token(EXCLUDE); + jj_consume_token(NULLS); + includeNulls = false; + } else { + includeNulls = false; + } + jj_consume_token(LPAREN); + measureList = SimpleIdentifierOrList(); + jj_consume_token(FOR); + axisList = SimpleIdentifierOrList(); + jj_consume_token(IN); + jj_consume_token(LPAREN); + s2 = span(); + UnpivotValue(values); + label_26: + while (true) { + if (jj_2_285(2)) { + ; + } else { + break label_26; + } + jj_consume_token(COMMA); + UnpivotValue(values); + } + jj_consume_token(RPAREN); + inList = new SqlNodeList(values, s2.end(this)); + jj_consume_token(RPAREN); + {if (true) return new SqlUnpivot(s.end(this), tableRef, includeNulls, measureList, + axisList, inList);} + throw new Error("Missing return statement in function"); + } + + final public void UnpivotValue(List list) throws ParseException { + final SqlNodeList columnList; + final SqlNode values; + columnList = SimpleIdentifierOrList(); + if (jj_2_286(2)) { + jj_consume_token(AS); + values = RowConstructor(); + final SqlNodeList valueList = SqlParserUtil.stripRow(values); + list.add( + SqlStdOperatorTable.AS.createCall(Span.of(columnList).end(this), + columnList, valueList)); + } else { + list.add(columnList); + } + } + +/** + * Parses a MATCH_RECOGNIZE clause following a table expression. + */ + final public SqlMatchRecognize MatchRecognize(SqlNode tableRef) throws ParseException { + final Span s, s0, s1, s2; + SqlNodeList measureList = SqlNodeList.EMPTY; + SqlNodeList partitionList = SqlNodeList.EMPTY; + SqlNodeList orderList = SqlNodeList.EMPTY; + SqlNode pattern; + SqlLiteral interval; + SqlNodeList patternDefList; + final SqlNode after; + SqlParserPos pos; + final SqlNode var; + final SqlLiteral rowsPerMatch; + SqlNodeList subsetList = SqlNodeList.EMPTY; + SqlLiteral isStrictStarts = SqlLiteral.createBoolean(false, getPos()); + SqlLiteral isStrictEnds = SqlLiteral.createBoolean(false, getPos()); + jj_consume_token(MATCH_RECOGNIZE); + s = span(); + jj_consume_token(LPAREN); + if (jj_2_287(2)) { + jj_consume_token(PARTITION); + s2 = span(); + jj_consume_token(BY); + partitionList = ExpressionCommaList(s2, ExprContext.ACCEPT_NON_QUERY); + } else { + ; + } + if (jj_2_288(2)) { + orderList = OrderBy(true); + } else { + ; + } + if (jj_2_289(2)) { + jj_consume_token(MEASURES); + measureList = MeasureColumnCommaList(span()); + } else { + ; + } + if (jj_2_290(2)) { + jj_consume_token(ONE); + s0 = span(); + jj_consume_token(ROW); + jj_consume_token(PER); + jj_consume_token(MATCH); + rowsPerMatch = SqlMatchRecognize.RowsPerMatchOption.ONE_ROW.symbol(s0.end(this)); + } else if (jj_2_291(2)) { + jj_consume_token(ALL); + s0 = span(); + jj_consume_token(ROWS); + jj_consume_token(PER); + jj_consume_token(MATCH); + rowsPerMatch = SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS.symbol(s0.end(this)); + } else { + rowsPerMatch = null; + } + if (jj_2_297(2)) { + jj_consume_token(AFTER); + s1 = span(); + jj_consume_token(MATCH); + jj_consume_token(SKIP_); + if (jj_2_295(2)) { + jj_consume_token(TO); + if (jj_2_293(2)) { + jj_consume_token(NEXT); + jj_consume_token(ROW); + after = SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW + .symbol(s1.end(this)); + } else if (jj_2_294(2)) { + jj_consume_token(FIRST); + var = SimpleIdentifier(); + after = SqlMatchRecognize.SKIP_TO_FIRST.createCall( + s1.end(var), var); + } else if (true) { + if (jj_2_292(2)) { + jj_consume_token(LAST); + } else { + ; + } + var = SimpleIdentifier(); + after = SqlMatchRecognize.SKIP_TO_LAST.createCall( + s1.end(var), var); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_296(2)) { + jj_consume_token(PAST); + jj_consume_token(LAST); + jj_consume_token(ROW); + after = SqlMatchRecognize.AfterOption.SKIP_PAST_LAST_ROW + .symbol(s1.end(this)); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + after = null; + } + jj_consume_token(PATTERN); + jj_consume_token(LPAREN); + if (jj_2_298(2)) { + jj_consume_token(CARET); + isStrictStarts = SqlLiteral.createBoolean(true, getPos()); + } else { + isStrictStarts = SqlLiteral.createBoolean(false, getPos()); + } + pattern = PatternExpression(); + if (jj_2_299(2)) { + jj_consume_token(DOLLAR); + isStrictEnds = SqlLiteral.createBoolean(true, getPos()); + } else { + isStrictEnds = SqlLiteral.createBoolean(false, getPos()); + } + jj_consume_token(RPAREN); + if (jj_2_300(2)) { + jj_consume_token(WITHIN); + interval = IntervalLiteral(); + } else { + interval = null; + } + if (jj_2_301(2)) { + jj_consume_token(SUBSET); + subsetList = SubsetDefinitionCommaList(span()); + } else { + ; + } + jj_consume_token(DEFINE); + patternDefList = PatternDefinitionCommaList(span()); + jj_consume_token(RPAREN); + {if (true) return new SqlMatchRecognize(s.end(this), tableRef, + pattern, isStrictStarts, isStrictEnds, patternDefList, measureList, + after, subsetList, rowsPerMatch, partitionList, orderList, interval);} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList MeasureColumnCommaList(Span s) throws ParseException { + SqlNode e; + final List eList = new ArrayList(); + e = MeasureColumn(); + eList.add(e); + label_27: + while (true) { + if (jj_2_302(2)) { + ; + } else { + break label_27; + } + jj_consume_token(COMMA); + e = MeasureColumn(); + eList.add(e); + } + {if (true) return new SqlNodeList(eList, s.addAll(eList).pos());} + throw new Error("Missing return statement in function"); + } + + final public SqlNode MeasureColumn() throws ParseException { + SqlNode e; + SqlIdentifier alias; + e = Expression(ExprContext.ACCEPT_NON_QUERY); + jj_consume_token(AS); + alias = SimpleIdentifier(); + {if (true) return SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e, alias);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode PatternExpression() throws ParseException { + SqlNode left; + SqlNode right; + left = PatternTerm(); + label_28: + while (true) { + if (jj_2_303(2)) { + ; + } else { + break label_28; + } + jj_consume_token(VERTICAL_BAR); + right = PatternTerm(); + left = SqlStdOperatorTable.PATTERN_ALTER.createCall( + Span.of(left).end(right), left, right); + } + {if (true) return left;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode PatternTerm() throws ParseException { + SqlNode left; + SqlNode right; + left = PatternFactor(); + label_29: + while (true) { + if (jj_2_304(2)) { + ; + } else { + break label_29; + } + right = PatternFactor(); + left = SqlStdOperatorTable.PATTERN_CONCAT.createCall( + Span.of(left).end(right), left, right); + } + {if (true) return left;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode PatternFactor() throws ParseException { + SqlNode e; + SqlNode extra; + SqlLiteral startNum = null; + SqlLiteral endNum = null; + SqlLiteral reluctant = SqlLiteral.createBoolean(false, SqlParserPos.ZERO); + e = PatternPrimary(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + case HOOK: + case PLUS: + case STAR: + if (jj_2_310(2)) { + jj_consume_token(STAR); + startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO); + endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO); + } else if (jj_2_311(2)) { + jj_consume_token(PLUS); + startNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO); + endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO); + } else if (jj_2_312(2)) { + jj_consume_token(HOOK); + startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO); + endNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO); + } else if (jj_2_313(2)) { + jj_consume_token(LBRACE); + if (jj_2_307(2)) { + startNum = UnsignedNumericLiteral(); + endNum = startNum; + if (jj_2_306(2)) { + jj_consume_token(COMMA); + endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO); + if (jj_2_305(2)) { + endNum = UnsignedNumericLiteral(); + } else { + ; + } + } else { + ; + } + jj_consume_token(RBRACE); + } else if (jj_2_308(2)) { + startNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO); + jj_consume_token(COMMA); + endNum = UnsignedNumericLiteral(); + jj_consume_token(RBRACE); + } else if (jj_2_309(2)) { + jj_consume_token(MINUS); + extra = PatternExpression(); + jj_consume_token(MINUS); + jj_consume_token(RBRACE); + extra = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall( + Span.of(extra).end(this), extra); + e = SqlStdOperatorTable.PATTERN_CONCAT.createCall( + Span.of(e).end(this), e, extra); + {if (true) return e;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_314(2)) { + jj_consume_token(HOOK); + if (startNum.intValue(true) != endNum.intValue(true)) { + reluctant = SqlLiteral.createBoolean(true, SqlParserPos.ZERO); + } + } else { + ; + } + break; + default: + jj_la1[2] = jj_gen; + ; + } + if (startNum == null) { + {if (true) return e;} + } else { + {if (true) return SqlStdOperatorTable.PATTERN_QUANTIFIER.createCall( + span().end(e), e, startNum, endNum, reluctant);} + } + throw new Error("Missing return statement in function"); + } + + final public SqlNode PatternPrimary() throws ParseException { + final Span s; + SqlNode e; + List eList; + if (jj_2_316(2)) { + e = SimpleIdentifier(); + } else if (jj_2_317(2)) { + jj_consume_token(LPAREN); + e = PatternExpression(); + jj_consume_token(RPAREN); + } else if (jj_2_318(2)) { + jj_consume_token(LBRACE); + s = span(); + jj_consume_token(MINUS); + e = PatternExpression(); + jj_consume_token(MINUS); + jj_consume_token(RBRACE); + e = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(s.end(this), e); + } else if (jj_2_319(2)) { + jj_consume_token(PERMUTE); + s = span(); + jj_consume_token(LPAREN); + e = PatternExpression(); + eList = new ArrayList(); + eList.add(e); + label_30: + while (true) { + if (jj_2_315(2)) { + ; + } else { + break label_30; + } + jj_consume_token(COMMA); + e = PatternExpression(); + eList.add(e); + } + jj_consume_token(RPAREN); + e = SqlStdOperatorTable.PATTERN_PERMUTE.createCall( + s.end(this), eList); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList SubsetDefinitionCommaList(Span s) throws ParseException { + SqlNode e; + final List eList = new ArrayList(); + e = SubsetDefinition(); + eList.add(e); + label_31: + while (true) { + if (jj_2_320(2)) { + ; + } else { + break label_31; + } + jj_consume_token(COMMA); + e = SubsetDefinition(); + eList.add(e); + } + {if (true) return new SqlNodeList(eList, s.addAll(eList).pos());} + throw new Error("Missing return statement in function"); + } + + final public SqlNode SubsetDefinition() throws ParseException { + final SqlNode var; + final SqlNodeList varList; + var = SimpleIdentifier(); + jj_consume_token(EQ); + jj_consume_token(LPAREN); + varList = ExpressionCommaList(span(), ExprContext.ACCEPT_NON_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.EQUALS.createCall(span().end(var), var, + varList);} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList PatternDefinitionCommaList(Span s) throws ParseException { + SqlNode e; + final List eList = new ArrayList(); + e = PatternDefinition(); + eList.add(e); + label_32: + while (true) { + if (jj_2_321(2)) { + ; + } else { + break label_32; + } + jj_consume_token(COMMA); + e = PatternDefinition(); + eList.add(e); + } + {if (true) return new SqlNodeList(eList, s.addAll(eList).pos());} + throw new Error("Missing return statement in function"); + } + + final public SqlNode PatternDefinition() throws ParseException { + final SqlNode var; + final SqlNode e; + var = SimpleIdentifier(); + jj_consume_token(AS); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return SqlStdOperatorTable.AS.createCall(Span.of(var, e).pos(), e, var);} + throw new Error("Missing return statement in function"); + } + +// ---------------------------------------------------------------------------- +// Expressions + +/** + * Parses a SQL expression (such as might occur in a WHERE clause) followed by + * the end-of-file symbol. + */ + final public SqlNode SqlExpressionEof() throws ParseException { + SqlNode e; + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(0); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses either a row expression or a query expression without ORDER BY. + */ + final public SqlNode QueryOrExpr(ExprContext exprContext) throws ParseException { + SqlNodeList withList = null; + SqlNode e; + SqlOperator op; + SqlParserPos pos; + SqlParserPos withPos; + List list; + if (jj_2_322(2)) { + withList = WithList(); + } else { + ; + } + e = LeafQueryOrExpr(exprContext); + list = startList(e); + label_33: + while (true) { + if (jj_2_323(2)) { + ; + } else { + break label_33; + } + if (!e.isA(SqlKind.QUERY)) { + // whoops, expression we just parsed wasn't a query, + // but we're about to see something like UNION, so + // force an exception retroactively + checkNonQueryExpression(ExprContext.ACCEPT_QUERY); + } + op = BinaryQueryOperator(); + // ensure a query is legal in this context + pos = getPos(); + checkQueryExpression(exprContext); + e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY); + list.add(new SqlParserUtil.ToTreeListItem(op, pos)); + list.add(e); + } + e = SqlParserUtil.toTree(list); + if (withList != null) { + e = new SqlWith(withList.getParserPosition(), withList, e); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList WithList() throws ParseException { + SqlWithItem withItem; + SqlParserPos pos; + SqlNodeList list; + jj_consume_token(WITH); + list = new SqlNodeList(getPos()); + withItem = WithItem(); + list.add(withItem); + label_34: + while (true) { + if (jj_2_324(2)) { + ; + } else { + break label_34; + } + jj_consume_token(COMMA); + withItem = WithItem(); + list.add(withItem); + } + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlWithItem WithItem() throws ParseException { + SqlIdentifier id; + SqlNodeList columnList = null; + SqlNode definition; + id = SimpleIdentifier(); + if (jj_2_325(2)) { + columnList = ParenthesizedSimpleIdentifierList(); + } else { + ; + } + jj_consume_token(AS); + definition = ParenthesizedExpression(ExprContext.ACCEPT_QUERY); + {if (true) return new SqlWithItem(id.getParserPosition(), id, columnList, + definition);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses either a row expression, a leaf query expression, or + * a parenthesized expression of any kind. + */ + final public SqlNode LeafQueryOrExpr(ExprContext exprContext) throws ParseException { + SqlNode e; + if (jj_2_326(2)) { + e = Expression(exprContext); + {if (true) return e;} + } else if (jj_2_327(2)) { + e = LeafQuery(exprContext); + {if (true) return e;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a row expression or a parenthesized expression of any kind. + */ + final public SqlNode Expression(ExprContext exprContext) throws ParseException { + List list; + SqlNode e; + list = Expression2(exprContext); + e = SqlParserUtil.toTree(list); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +// TODO jvs 15-Nov-2003: ANY/ALL + final public void Expression2b(ExprContext exprContext, List list) throws ParseException { + SqlNode e; + SqlOperator op; + SqlNode ext; + label_35: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EXISTS: + case NOT: + case UNIQUE: + case PLUS: + case MINUS: + ; + break; + default: + jj_la1[3] = jj_gen; + break label_35; + } + op = PrefixRowOperator(); + checkNonQueryExpression(exprContext); + list.add(new SqlParserUtil.ToTreeListItem(op, getPos())); + } + e = Expression3(exprContext); + list.add(e); + label_36: + while (true) { + if (jj_2_328(2)) { + ; + } else { + break label_36; + } + jj_consume_token(DOT); + ext = RowExpressionExtension(); + list.add( + new SqlParserUtil.ToTreeListItem( + SqlStdOperatorTable.DOT, getPos())); + list.add(ext); + } + } + +/** + * Parses a binary row expression, or a parenthesized expression of any + * kind. + * + *

The result is as a flat list of operators and operands. The top-level + * call to get an expression should call {@link #Expression}, but lower-level + * calls should call this, to give the parser the opportunity to associate + * operator calls. + * + *

For example 'a = b like c = d' should come out '((a = b) like c) = d' + * because LIKE and '=' have the same precedence, but tends to come out as '(a + * = b) like (c = d)' because (a = b) and (c = d) are parsed as separate + * expressions. + */ + final public List Expression2(ExprContext exprContext) throws ParseException { + final List list = new ArrayList(); + List list2; + final List list3 = new ArrayList(); + SqlNodeList nodeList; + SqlNode e; + SqlOperator op; + SqlIdentifier p; + final Span s = span(); + Expression2b(exprContext, list); + if (jj_2_367(2)) { + label_37: + while (true) { + if (jj_2_359(2)) { + checkNonQueryExpression(exprContext); + if (jj_2_332(2)) { + jj_consume_token(NOT); + jj_consume_token(IN); + op = SqlStdOperatorTable.NOT_IN; + } else if (jj_2_333(2)) { + jj_consume_token(IN); + op = SqlStdOperatorTable.IN; + } else if (jj_2_334(2)) { + final SqlKind k; + k = comp(); + if (jj_2_329(2)) { + jj_consume_token(SOME); + op = SqlStdOperatorTable.some(k); + } else if (jj_2_330(2)) { + jj_consume_token(ANY); + op = SqlStdOperatorTable.some(k); + } else if (jj_2_331(2)) { + jj_consume_token(ALL); + op = SqlStdOperatorTable.all(k); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s.clear().add(this); + nodeList = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_NONCURSOR); + list.add(new SqlParserUtil.ToTreeListItem(op, s.pos())); + s.add(nodeList); + // special case for stuff like IN (s1 UNION s2) + if (nodeList.size() == 1) { + SqlNode item = nodeList.get(0); + if (item.isA(SqlKind.QUERY)) { + list.add(item); + } else { + list.add(nodeList); + } + } else { + list.add(nodeList); + } + } else if (jj_2_360(2)) { + checkNonQueryExpression(exprContext); + if (jj_2_341(2)) { + jj_consume_token(NOT); + jj_consume_token(BETWEEN); + op = SqlStdOperatorTable.NOT_BETWEEN; + s.clear().add(this); + if (jj_2_337(2)) { + if (jj_2_335(2)) { + jj_consume_token(SYMMETRIC); + op = SqlStdOperatorTable.SYMMETRIC_NOT_BETWEEN; + } else if (jj_2_336(2)) { + jj_consume_token(ASYMMETRIC); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + } else if (jj_2_342(2)) { + jj_consume_token(BETWEEN); + op = SqlStdOperatorTable.BETWEEN; + s.clear().add(this); + if (jj_2_340(2)) { + if (jj_2_338(2)) { + jj_consume_token(SYMMETRIC); + op = SqlStdOperatorTable.SYMMETRIC_BETWEEN; + } else if (jj_2_339(2)) { + jj_consume_token(ASYMMETRIC); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + Expression2b(ExprContext.ACCEPT_SUB_QUERY, list3); + list.add(new SqlParserUtil.ToTreeListItem(op, s.pos())); + list.addAll(list3); + list3.clear(); + } else if (jj_2_361(2)) { + checkNonQueryExpression(exprContext); + s.clear().add(this); + if (jj_2_354(2)) { + if (jj_2_347(2)) { + jj_consume_token(NOT); + if (jj_2_343(2)) { + jj_consume_token(LIKE); + op = SqlStdOperatorTable.NOT_LIKE; + } else if (jj_2_344(2)) { + jj_consume_token(ILIKE); + op = SqlLibraryOperators.NOT_ILIKE; + } else if (jj_2_345(2)) { + jj_consume_token(RLIKE); + op = SqlLibraryOperators.NOT_RLIKE; + } else if (jj_2_346(2)) { + jj_consume_token(SIMILAR); + jj_consume_token(TO); + op = SqlStdOperatorTable.NOT_SIMILAR_TO; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_348(2)) { + jj_consume_token(LIKE); + op = SqlStdOperatorTable.LIKE; + } else if (jj_2_349(2)) { + jj_consume_token(ILIKE); + op = SqlLibraryOperators.ILIKE; + } else if (jj_2_350(2)) { + jj_consume_token(RLIKE); + op = SqlLibraryOperators.RLIKE; + } else if (jj_2_351(2)) { + jj_consume_token(SIMILAR); + jj_consume_token(TO); + op = SqlStdOperatorTable.SIMILAR_TO; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_355(2)) { + jj_consume_token(NEGATE); + jj_consume_token(TILDE); + op = SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_SENSITIVE; + if (jj_2_352(2)) { + jj_consume_token(STAR); + op = SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_INSENSITIVE; + } else { + ; + } + } else if (jj_2_356(2)) { + jj_consume_token(TILDE); + op = SqlStdOperatorTable.POSIX_REGEX_CASE_SENSITIVE; + if (jj_2_353(2)) { + jj_consume_token(STAR); + op = SqlStdOperatorTable.POSIX_REGEX_CASE_INSENSITIVE; + } else { + ; + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + list2 = Expression2(ExprContext.ACCEPT_SUB_QUERY); + list.add(new SqlParserUtil.ToTreeListItem(op, s.pos())); + list.addAll(list2); + if (jj_2_357(2)) { + jj_consume_token(ESCAPE); + e = Expression3(ExprContext.ACCEPT_SUB_QUERY); + s.clear().add(this); + list.add( + new SqlParserUtil.ToTreeListItem( + SqlStdOperatorTable.ESCAPE, s.pos())); + list.add(e); + } else { + ; + } + } else if (jj_2_362(2)) { + InfixCast(list, exprContext, s); + } else if (jj_2_363(3)) { + op = BinaryRowOperator(); + checkNonQueryExpression(exprContext); + list.add(new SqlParserUtil.ToTreeListItem(op, getPos())); + Expression2b(ExprContext.ACCEPT_SUB_QUERY, list); + } else if (jj_2_364(2)) { + jj_consume_token(LBRACKET); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RBRACKET); + list.add( + new SqlParserUtil.ToTreeListItem( + SqlStdOperatorTable.ITEM, getPos())); + list.add(e); + label_38: + while (true) { + if (jj_2_358(2)) { + ; + } else { + break label_38; + } + jj_consume_token(DOT); + p = SimpleIdentifier(); + list.add( + new SqlParserUtil.ToTreeListItem( + SqlStdOperatorTable.DOT, getPos())); + list.add(p); + } + } else if (jj_2_365(2)) { + checkNonQueryExpression(exprContext); + op = PostfixRowOperator(); + list.add(new SqlParserUtil.ToTreeListItem(op, getPos())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_366(2)) { + ; + } else { + break label_37; + } + } + {if (true) return list;} + } else { + {if (true) return list;} + } + throw new Error("Missing return statement in function"); + } + +/** Parses a comparison operator inside a SOME / ALL predicate. */ + final public SqlKind comp() throws ParseException { + if (jj_2_368(2)) { + jj_consume_token(LT); + {if (true) return SqlKind.LESS_THAN;} + } else if (jj_2_369(2)) { + jj_consume_token(LE); + {if (true) return SqlKind.LESS_THAN_OR_EQUAL;} + } else if (jj_2_370(2)) { + jj_consume_token(GT); + {if (true) return SqlKind.GREATER_THAN;} + } else if (jj_2_371(2)) { + jj_consume_token(GE); + {if (true) return SqlKind.GREATER_THAN_OR_EQUAL;} + } else if (jj_2_372(2)) { + jj_consume_token(EQ); + {if (true) return SqlKind.EQUALS;} + } else if (jj_2_373(2)) { + jj_consume_token(NE); + {if (true) return SqlKind.NOT_EQUALS;} + } else if (jj_2_374(2)) { + jj_consume_token(NE2); + if (!this.conformance.isBangEqualAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.bangEqualNotAllowed());} + } + {if (true) return SqlKind.NOT_EQUALS;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a unary row expression, or a parenthesized expression of any + * kind. + */ + final public SqlNode Expression3(ExprContext exprContext) throws ParseException { + final SqlNode e; + final SqlNodeList list; + final SqlNodeList list1; + final SqlNodeList list2; + final SqlOperator op; + final Span s; + Span rowSpan = null; + if (jj_2_377(2)) { + e = AtomicRowExpression(); + checkNonQueryExpression(exprContext); + {if (true) return e;} + } else if (jj_2_378(2)) { + e = CursorExpression(exprContext); + {if (true) return e;} + } else if (jj_2_379(3)) { + jj_consume_token(ROW); + s = span(); + list = ParenthesizedQueryOrCommaList(exprContext); + if (exprContext != ExprContext.ACCEPT_ALL + && exprContext != ExprContext.ACCEPT_CURSOR + && !this.conformance.allowExplicitRowValueConstructor()) + { + {if (true) throw SqlUtil.newContextException(s.end(list), + RESOURCE.illegalRowExpression());} + } + {if (true) return SqlStdOperatorTable.ROW.createCall(list);} + } else if (jj_2_380(2)) { + if (jj_2_375(2)) { + jj_consume_token(ROW); + rowSpan = span(); + } else { + ; + } + list1 = ParenthesizedQueryOrCommaList(exprContext); + if (rowSpan != null) { + // interpret as row constructor + {if (true) return SqlStdOperatorTable.ROW.createCall(rowSpan.end(list1), + (List) list1);} + } + if (jj_2_376(2)) { + e = IntervalQualifier(); + if ((list1.size() == 1) + && list1.get(0) instanceof SqlCall) + { + final SqlCall call = (SqlCall) list1.get(0); + if (call.getKind() == SqlKind.MINUS + && call.operandCount() == 2) { + List list3 = startList(call.operand(0)); + list3.add(call.operand(1)); + list3.add(e); + {if (true) return SqlStdOperatorTable.MINUS_DATE.createCall( + Span.of(list1).end(this), list3);} + } + } + {if (true) throw SqlUtil.newContextException(span().end(list1), + RESOURCE.illegalMinusDate());} + } else { + ; + } + if (list1.size() == 1) { + // interpret as single value or query + {if (true) return list1.get(0);} + } else { + // interpret as row constructor + {if (true) return SqlStdOperatorTable.ROW.createCall(span().end(list1), + (List) list1);} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlOperator periodOperator() throws ParseException { + if (jj_2_381(2)) { + jj_consume_token(OVERLAPS); + {if (true) return SqlStdOperatorTable.OVERLAPS;} + } else if (jj_2_382(2)) { + jj_consume_token(IMMEDIATELY); + jj_consume_token(PRECEDES); + {if (true) return SqlStdOperatorTable.IMMEDIATELY_PRECEDES;} + } else if (jj_2_383(2)) { + jj_consume_token(PRECEDES); + {if (true) return SqlStdOperatorTable.PRECEDES;} + } else if (jj_2_384(2)) { + jj_consume_token(IMMEDIATELY); + jj_consume_token(SUCCEEDS); + {if (true) return SqlStdOperatorTable.IMMEDIATELY_SUCCEEDS;} + } else if (jj_2_385(2)) { + jj_consume_token(SUCCEEDS); + {if (true) return SqlStdOperatorTable.SUCCEEDS;} + } else if (jj_2_386(2)) { + jj_consume_token(EQUALS); + {if (true) return SqlStdOperatorTable.PERIOD_EQUALS;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a COLLATE clause + */ + final public SqlCollation CollateClause() throws ParseException { + jj_consume_token(COLLATE); + jj_consume_token(COLLATION_ID); + {if (true) return new SqlCollation( + getToken(0).image, SqlCollation.Coercibility.EXPLICIT);} + throw new Error("Missing return statement in function"); + } + +/** + * Numeric literal or parameter; used in LIMIT, OFFSET and FETCH clauses. + */ + final public SqlNode UnsignedNumericLiteralOrParam() throws ParseException { + final SqlNode e; + if (jj_2_387(2)) { + e = UnsignedNumericLiteral(); + } else if (jj_2_388(2)) { + e = DynamicParam(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a row expression extension, it can be either an identifier, + * or a call to a named function. + */ + final public SqlNode RowExpressionExtension() throws ParseException { + final SqlFunctionCategory funcType; + final SqlIdentifier p; + final Span s; + final List args; + SqlCall call; + SqlNode e; + SqlLiteral quantifier = null; + p = SimpleIdentifier(); + e = p; + if (jj_2_392(2147483647)) { + s = span(); + funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION; + if (jj_2_389(2)) { + jj_consume_token(LPAREN); + jj_consume_token(STAR); + args = startList(SqlIdentifier.star(getPos())); + jj_consume_token(RPAREN); + } else if (jj_2_390(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + args = Collections.emptyList(); + } else if (jj_2_391(2)) { + args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY); + quantifier = (SqlLiteral) args.get(0); + args.remove(0); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + call = createCall(p, s.end(this), funcType, quantifier, args); + e = call; + } else { + ; + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to the STRING_AGG aggregate function (or to an aggregate + * function with similar syntax: ARRAY_AGG, ARRAY_CONCAT_AGG, GROUP_CONCAT). + */ + final public SqlCall StringAggFunctionCall() throws ParseException { + final Span s, s2; + final SqlOperator op; + final List args = new ArrayList(); + final SqlLiteral qualifier; + final SqlNodeList orderBy; + final Pair nullTreatment; + final SqlNode separator; + if (jj_2_393(2)) { + jj_consume_token(ARRAY_AGG); + s = span(); op = SqlLibraryOperators.ARRAY_AGG; + } else if (jj_2_394(2)) { + jj_consume_token(ARRAY_CONCAT_AGG); + s = span(); op = SqlLibraryOperators.ARRAY_CONCAT_AGG; + } else if (jj_2_395(2)) { + jj_consume_token(GROUP_CONCAT); + s = span(); op = SqlLibraryOperators.GROUP_CONCAT; + } else if (jj_2_396(2)) { + jj_consume_token(STRING_AGG); + s = span(); op = SqlLibraryOperators.STRING_AGG; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(LPAREN); + if (jj_2_397(2)) { + qualifier = AllOrDistinct(); + } else { + qualifier = null; + } + Arg(args, ExprContext.ACCEPT_SUB_QUERY); + label_39: + while (true) { + if (jj_2_398(2)) { + ; + } else { + break label_39; + } + jj_consume_token(COMMA); + // a comma-list can't appear where only a query is expected + checkNonQueryExpression(ExprContext.ACCEPT_SUB_QUERY); + Arg(args, ExprContext.ACCEPT_SUB_QUERY); + } + if (jj_2_399(2)) { + nullTreatment = NullTreatment(); + } else { + nullTreatment = null; + } + if (jj_2_400(2)) { + orderBy = OrderBy(true); + args.add(orderBy); + } else { + ; + } + if (jj_2_401(2)) { + jj_consume_token(SEPARATOR); + s2 = span(); + separator = StringLiteral(); + args.add(SqlInternalOperators.SEPARATOR.createCall(s2.end(this), separator)); + } else { + ; + } + jj_consume_token(RPAREN); + SqlCall call = op.createCall(qualifier, s.end(this), args); + if (nullTreatment != null) { + // Wrap in RESPECT_NULLS or IGNORE_NULLS. + call = nullTreatment.right.createCall(nullTreatment.left, call); + } + {if (true) return call;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an atomic row expression. + */ + final public SqlNode AtomicRowExpression() throws ParseException { + final SqlNode e; + if (jj_2_402(2)) { + e = LiteralOrIntervalExpression(); + } else if (jj_2_403(2)) { + e = DynamicParam(); + } else if (jj_2_404(2)) { + e = BuiltinFunctionCall(); + } else if (jj_2_405(2)) { + e = JdbcFunctionCall(); + } else if (jj_2_406(2)) { + e = MultisetConstructor(); + } else if (jj_2_407(2)) { + e = ArrayConstructor(); + } else if (jj_2_408(3)) { + e = MapConstructor(); + } else if (jj_2_409(2)) { + e = PeriodConstructor(); + } else if (jj_2_410(2147483647)) { + e = NamedFunctionCall(); + } else if (jj_2_411(2)) { + e = ContextVariable(); + } else if (jj_2_412(2)) { + e = CompoundIdentifier(); + } else if (jj_2_413(2)) { + e = NewSpecification(); + } else if (jj_2_414(2)) { + e = CaseExpression(); + } else if (jj_2_415(2)) { + e = SequenceExpression(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode CaseExpression() throws ParseException { + final Span whenSpan = Span.of(); + final Span thenSpan = Span.of(); + final Span s; + SqlNode e; + SqlNode caseIdentifier = null; + SqlNode elseClause = null; + List whenList = new ArrayList(); + List thenList = new ArrayList(); + jj_consume_token(CASE); + s = span(); + if (jj_2_416(2)) { + caseIdentifier = Expression(ExprContext.ACCEPT_SUB_QUERY); + } else { + ; + } + label_40: + while (true) { + jj_consume_token(WHEN); + whenSpan.add(this); + e = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY); + if (((SqlNodeList) e).size() == 1) { + e = ((SqlNodeList) e).get(0); + } + whenList.add(e); + jj_consume_token(THEN); + thenSpan.add(this); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + thenList.add(e); + if (jj_2_417(2)) { + ; + } else { + break label_40; + } + } + if (jj_2_418(2)) { + jj_consume_token(ELSE); + elseClause = Expression(ExprContext.ACCEPT_SUB_QUERY); + } else { + ; + } + jj_consume_token(END); + {if (true) return SqlCase.createSwitched(s.end(this), caseIdentifier, + new SqlNodeList(whenList, whenSpan.addAll(whenList).pos()), + new SqlNodeList(thenList, thenSpan.addAll(thenList).pos()), + elseClause);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall SequenceExpression() throws ParseException { + final Span s; + final SqlOperator f; + final SqlNode sequenceRef; + if (jj_2_419(2)) { + jj_consume_token(NEXT); + f = SqlStdOperatorTable.NEXT_VALUE; s = span(); + } else if (jj_2_420(3)) { + jj_consume_token(CURRENT); + f = SqlStdOperatorTable.CURRENT_VALUE; s = span(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(VALUE); + jj_consume_token(FOR); + sequenceRef = CompoundIdentifier(); + {if (true) return f.createCall(s.end(sequenceRef), sequenceRef);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses "SET <NAME> = VALUE" or "RESET <NAME>", without a leading + * "ALTER <SCOPE>". + */ + final public SqlSetOption SqlSetOption(Span s, String scope) throws ParseException { + SqlIdentifier name; + final SqlNode val; + if (jj_2_426(2)) { + jj_consume_token(SET); + s.add(this); + name = CompoundIdentifier(); + jj_consume_token(EQ); + if (jj_2_421(2)) { + val = Literal(); + } else if (jj_2_422(2)) { + val = SimpleIdentifier(); + } else if (jj_2_423(2)) { + jj_consume_token(ON); + // OFF is handled by SimpleIdentifier, ON handled here. + val = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT), + getPos()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlSetOption(s.end(val), scope, name, val);} + } else if (jj_2_427(2)) { + jj_consume_token(RESET); + s.add(this); + if (jj_2_424(2)) { + name = CompoundIdentifier(); + } else if (jj_2_425(2)) { + jj_consume_token(ALL); + name = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT), + getPos()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlSetOption(s.end(name), scope, name, null);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses an expression for setting or resetting an option in SQL, such as QUOTED_IDENTIFIERS, + * or explain plan level (physical/logical). + */ + final public SqlAlter SqlAlter() throws ParseException { + final Span s; + final String scope; + final SqlAlter alterNode; + jj_consume_token(ALTER); + s = span(); + scope = Scope(); + alterNode = SqlSetOption(s, scope); + {if (true) return alterNode;} + throw new Error("Missing return statement in function"); + } + + final public String Scope() throws ParseException { + if (jj_2_428(2)) { + jj_consume_token(SYSTEM); + } else if (jj_2_429(2)) { + jj_consume_token(SESSION); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return token.image.toUpperCase(Locale.ROOT);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a CREATE statement. + */ + final public SqlCreate SqlCreate() throws ParseException { + final Span s; + boolean replace = false; + final SqlCreate create; + jj_consume_token(CREATE); + s = span(); + if (jj_2_430(2)) { + jj_consume_token(OR); + jj_consume_token(REPLACE); + replace = true; + } else { + ; + } + if (jj_2_431(2)) { + create = SqlCreateTable(s, replace); + } else if (jj_2_432(2)) { + create = SqlCreateIndex(s, replace); + } else if (jj_2_433(2)) { + create = SqlCreateUser(s, replace); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return create;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a DROP statement. + */ + final public SqlDrop SqlDrop() throws ParseException { + final Span s; + boolean replace = false; + final SqlDrop drop; + jj_consume_token(DROP); + s = span(); + if (jj_2_434(2)) { + drop = SqlDropTable(s, replace); + } else if (jj_2_435(2)) { + drop = SqlDropIndex(s, replace); + } else if (jj_2_436(2)) { + drop = SqlDropUser(s, replace); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return drop;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a literal expression, allowing continued string literals. + * Usually returns an SqlLiteral, but a continued string literal + * is an SqlCall expression, which concatenates 2 or more string + * literals; the validator reduces this. + * + *

If the context allows both literals and expressions, + * use {@link #LiteralOrIntervalExpression}, which requires less + * lookahead. + */ + final public SqlNode Literal() throws ParseException { + SqlNode e; + if (jj_2_437(2)) { + e = NonIntervalLiteral(); + } else if (jj_2_438(2)) { + e = IntervalLiteral(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** Parses a literal that is not an interval literal. */ + final public SqlNode NonIntervalLiteral() throws ParseException { + final SqlNode e; + if (jj_2_439(2)) { + e = NumericLiteral(); + } else if (jj_2_440(2)) { + e = StringLiteral(); + } else if (jj_2_441(2)) { + e = SpecialLiteral(); + } else if (jj_2_442(2)) { + e = DateTimeLiteral(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** Parses a literal or an interval expression. + * + *

We include them in the same production because it is difficult to + * distinguish interval literals from interval expression (both of which + * start with the {@code INTERVAL} keyword); this way, we can use less + * LOOKAHEAD. */ + final public SqlNode LiteralOrIntervalExpression() throws ParseException { + final SqlNode e; + if (jj_2_443(2)) { + e = IntervalLiteralOrExpression(); + } else if (jj_2_444(2)) { + e = NonIntervalLiteral(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + +/** Parses a unsigned numeric literal */ + final public SqlNumericLiteral UnsignedNumericLiteral() throws ParseException { + if (jj_2_445(2)) { + jj_consume_token(UNSIGNED_INTEGER_LITERAL); + {if (true) return SqlLiteral.createExactNumeric(token.image, getPos());} + } else if (jj_2_446(2)) { + jj_consume_token(DECIMAL_NUMERIC_LITERAL); + {if (true) return SqlLiteral.createExactNumeric(token.image, getPos());} + } else if (jj_2_447(2)) { + jj_consume_token(APPROX_NUMERIC_LITERAL); + {if (true) return SqlLiteral.createApproxNumeric(token.image, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** Parses a numeric literal (can be signed) */ + final public SqlLiteral NumericLiteral() throws ParseException { + final SqlNumericLiteral num; + final Span s; + if (jj_2_448(2)) { + jj_consume_token(PLUS); + num = UnsignedNumericLiteral(); + {if (true) return num;} + } else if (jj_2_449(2)) { + jj_consume_token(MINUS); + s = span(); + num = UnsignedNumericLiteral(); + {if (true) return SqlLiteral.createNegative(num, s.end(this));} + } else if (jj_2_450(2)) { + num = UnsignedNumericLiteral(); + {if (true) return num;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** Parse a special literal keyword */ + final public SqlLiteral SpecialLiteral() throws ParseException { + if (jj_2_451(2)) { + jj_consume_token(TRUE); + {if (true) return SqlLiteral.createBoolean(true, getPos());} + } else if (jj_2_452(2)) { + jj_consume_token(FALSE); + {if (true) return SqlLiteral.createBoolean(false, getPos());} + } else if (jj_2_453(2)) { + jj_consume_token(UNKNOWN); + {if (true) return SqlLiteral.createUnknown(getPos());} + } else if (jj_2_454(2)) { + jj_consume_token(NULL); + {if (true) return SqlLiteral.createNull(getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a string literal. The literal may be continued onto several + * lines. For a simple literal, the result is an SqlLiteral. For a continued + * literal, the result is an SqlCall expression, which concatenates 2 or more + * string literals; the validator reduces this. + * + * @see SqlLiteral#unchain(SqlNode) + * @see SqlLiteral#stringValue(SqlNode) + * + * @return a literal expression + */ + final public SqlNode StringLiteral() throws ParseException { + String p; + int nfrags = 0; + List frags = null; + char unicodeEscapeChar = 0; + String charSet = null; + SqlCharStringLiteral literal; + if (jj_2_459(2)) { + jj_consume_token(BINARY_STRING_LITERAL); + try { + p = SqlParserUtil.trim(token.image, "xX'"); + frags = startList(SqlLiteral.createBinaryString(p, getPos())); + nfrags++; + } catch (NumberFormatException ex) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.illegalBinaryString(token.image));} + } + label_41: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUOTED_STRING: + ; + break; + default: + jj_la1[4] = jj_gen; + break label_41; + } + jj_consume_token(QUOTED_STRING); + try { + p = SqlParserUtil.trim(token.image, "'"); // no embedded quotes + frags.add(SqlLiteral.createBinaryString(p, getPos())); + nfrags++; + } catch (NumberFormatException ex) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.illegalBinaryString(token.image));} + } + } + assert (nfrags > 0); + if (nfrags == 1) { + {if (true) return frags.get(0);} // just the head fragment + } else { + SqlParserPos pos2 = SqlParserPos.sum(frags); + {if (true) return SqlStdOperatorTable.LITERAL_CHAIN.createCall(pos2, frags);} + } + } else if (jj_2_460(2)) { + if (jj_2_455(2)) { + jj_consume_token(PREFIXED_STRING_LITERAL); + charSet = SqlParserUtil.getCharacterSet(token.image); + } else if (jj_2_456(2)) { + jj_consume_token(QUOTED_STRING); + } else if (jj_2_457(2)) { + jj_consume_token(UNICODE_STRING_LITERAL); + // TODO jvs 2-Feb-2009: support the explicit specification of + // a character set for Unicode string literals, per SQL:2003 + unicodeEscapeChar = BACKSLASH; + charSet = "UTF16"; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + p = SqlParserUtil.parseString(token.image); + try { + literal = SqlLiteral.createCharString(p, charSet, getPos()); + } catch (java.nio.charset.UnsupportedCharsetException e) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.unknownCharacterSet(charSet));} + } + frags = startList(literal); + nfrags++; + label_42: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUOTED_STRING: + ; + break; + default: + jj_la1[5] = jj_gen; + break label_42; + } + jj_consume_token(QUOTED_STRING); + p = SqlParserUtil.parseString(token.image); + try { + literal = SqlLiteral.createCharString(p, charSet, getPos()); + } catch (java.nio.charset.UnsupportedCharsetException e) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.unknownCharacterSet(charSet));} + } + frags.add(literal); + nfrags++; + } + if (jj_2_458(2)) { + jj_consume_token(UESCAPE); + jj_consume_token(QUOTED_STRING); + if (unicodeEscapeChar == 0) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.unicodeEscapeUnexpected());} + } + String s = SqlParserUtil.parseString(token.image); + unicodeEscapeChar = SqlParserUtil.checkUnicodeEscapeChar(s); + } else { + ; + } + assert nfrags > 0; + if (nfrags == 1) { + // just the head fragment + SqlLiteral lit = (SqlLiteral) frags.get(0); + {if (true) return lit.unescapeUnicode(unicodeEscapeChar);} + } else { + SqlNode[] rands = (SqlNode[]) frags.toArray(new SqlNode[nfrags]); + for (int i = 0; i < rands.length; ++i) { + rands[i] = ((SqlLiteral) rands[i]).unescapeUnicode( + unicodeEscapeChar); + } + SqlParserPos pos2 = SqlParserPos.sum(rands); + {if (true) return SqlStdOperatorTable.LITERAL_CHAIN.createCall(pos2, rands);} + } + } else if (jj_2_461(2)) { + jj_consume_token(BIG_QUERY_DOUBLE_QUOTED_STRING); + p = SqlParserUtil.stripQuotes(getToken(0).image, DQ, DQ, "\\\"", + Casing.UNCHANGED); + try { + {if (true) return SqlLiteral.createCharString(p, charSet, getPos());} + } catch (java.nio.charset.UnsupportedCharsetException e) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.unknownCharacterSet(charSet));} + } + } else if (jj_2_462(2)) { + jj_consume_token(BIG_QUERY_QUOTED_STRING); + p = SqlParserUtil.stripQuotes(getToken(0).image, "'", "'", "\\'", + Casing.UNCHANGED); + try { + {if (true) return SqlLiteral.createCharString(p, charSet, getPos());} + } catch (java.nio.charset.UnsupportedCharsetException e) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.unknownCharacterSet(charSet));} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a date/time literal. + */ + final public SqlLiteral DateTimeLiteral() throws ParseException { + final String p; + final Span s; + if (jj_2_463(2)) { + jj_consume_token(LBRACE_D); + jj_consume_token(QUOTED_STRING); + p = token.image; + jj_consume_token(RBRACE); + {if (true) return SqlParserUtil.parseDateLiteral(p, getPos());} + } else if (jj_2_464(2)) { + jj_consume_token(LBRACE_T); + jj_consume_token(QUOTED_STRING); + p = token.image; + jj_consume_token(RBRACE); + {if (true) return SqlParserUtil.parseTimeLiteral(p, getPos());} + } else if (jj_2_465(2)) { + jj_consume_token(LBRACE_TS); + s = span(); + jj_consume_token(QUOTED_STRING); + p = token.image; + jj_consume_token(RBRACE); + {if (true) return SqlParserUtil.parseTimestampLiteral(p, s.end(this));} + } else if (jj_2_466(2)) { + jj_consume_token(DATE); + s = span(); + jj_consume_token(QUOTED_STRING); + {if (true) return SqlParserUtil.parseDateLiteral(token.image, s.end(this));} + } else if (jj_2_467(2)) { + jj_consume_token(TIME); + s = span(); + jj_consume_token(QUOTED_STRING); + {if (true) return SqlParserUtil.parseTimeLiteral(token.image, s.end(this));} + } else if (jj_2_468(2)) { + jj_consume_token(TIMESTAMP); + s = span(); + jj_consume_token(QUOTED_STRING); + {if (true) return SqlParserUtil.parseTimestampLiteral(token.image, s.end(this));} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** Parses a MULTISET constructor */ + final public SqlNode MultisetConstructor() throws ParseException { + List args; + SqlNode e; + final Span s; + jj_consume_token(MULTISET); + s = span(); + if (jj_2_470(2)) { + jj_consume_token(LPAREN); + // by sub query "MULTISET(SELECT * FROM T)" + e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.MULTISET_QUERY.createCall( + s.end(this), e);} + } else if (jj_2_471(2)) { + jj_consume_token(LBRACKET); + // TODO: do trigraph as well ??( ??) + e = Expression(ExprContext.ACCEPT_NON_QUERY); + args = startList(e); + label_43: + while (true) { + if (jj_2_469(2)) { + ; + } else { + break label_43; + } + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + args.add(e); + } + jj_consume_token(RBRACKET); + {if (true) return SqlStdOperatorTable.MULTISET_VALUE.createCall( + s.end(this), args);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** Parses an ARRAY constructor */ + final public SqlNode ArrayConstructor() throws ParseException { + SqlNodeList args; + SqlNode e; + final Span s; + jj_consume_token(ARRAY); + s = span(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + jj_consume_token(LPAREN); + // by sub query "MULTISET(SELECT * FROM T)" + e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.ARRAY_QUERY.createCall( + s.end(this), e);} + break; + default: + jj_la1[6] = jj_gen; + if (jj_2_473(2)) { + jj_consume_token(LBRACKET); + if (jj_2_472(2)) { + args = ExpressionCommaList(s, ExprContext.ACCEPT_NON_QUERY); + } else { + args = SqlNodeList.EMPTY; + } + jj_consume_token(RBRACKET); + {if (true) return SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR.createCall( + s.end(this), args.getList());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + +/** Parses a MAP constructor */ + final public SqlNode MapConstructor() throws ParseException { + SqlNodeList args; + SqlNode e; + final Span s; + jj_consume_token(MAP); + s = span(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + jj_consume_token(LPAREN); + // by sub query "MAP (SELECT empno, deptno FROM emp)" + e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.MAP_QUERY.createCall( + s.end(this), e);} + break; + default: + jj_la1[7] = jj_gen; + if (jj_2_475(2)) { + jj_consume_token(LBRACKET); + if (jj_2_474(2)) { + args = ExpressionCommaList(s, ExprContext.ACCEPT_NON_QUERY); + } else { + args = SqlNodeList.EMPTY; + } + jj_consume_token(RBRACKET); + {if (true) return SqlStdOperatorTable.MAP_VALUE_CONSTRUCTOR.createCall( + s.end(this), args.getList());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + +/** Parses a PERIOD constructor */ + final public SqlNode PeriodConstructor() throws ParseException { + final SqlNode e0, e1; + final Span s; + jj_consume_token(PERIOD); + s = span(); + jj_consume_token(LPAREN); + e0 = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(COMMA); + e1 = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.ROW.createCall(s.end(this), e0, e1);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses an interval literal. + */ + final public SqlLiteral IntervalLiteral() throws ParseException { + final String p; + final SqlIntervalQualifier intervalQualifier; + int sign = 1; + final Span s; + jj_consume_token(INTERVAL); + s = span(); + if (jj_2_478(2)) { + if (jj_2_476(2)) { + jj_consume_token(MINUS); + sign = -1; + } else if (jj_2_477(2)) { + jj_consume_token(PLUS); + sign = 1; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + jj_consume_token(QUOTED_STRING); + p = token.image; + intervalQualifier = IntervalQualifier(); + {if (true) return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier), + sign, p, intervalQualifier);} + throw new Error("Missing return statement in function"); + } + +/** Parses an interval literal (e.g. {@code INTERVAL '2:3' HOUR TO MINUTE}) + * or an interval expression (e.g. {@code INTERVAL emp.empno MINUTE} + * or {@code INTERVAL 3 MONTHS}). */ + final public SqlNode IntervalLiteralOrExpression() throws ParseException { + final String p; + final SqlIntervalQualifier intervalQualifier; + int sign = 1; + final Span s; + SqlNode e; + jj_consume_token(INTERVAL); + s = span(); + if (jj_2_481(2)) { + if (jj_2_479(2)) { + jj_consume_token(MINUS); + sign = -1; + } else if (jj_2_480(2)) { + jj_consume_token(PLUS); + sign = 1; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + if (jj_2_485(2)) { + jj_consume_token(QUOTED_STRING); + p = token.image; + intervalQualifier = IntervalQualifier(); + {if (true) return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier), + sign, p, intervalQualifier);} + } else if (jj_2_486(2)) { + if (jj_2_482(2)) { + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + } else if (jj_2_483(2)) { + e = UnsignedNumericLiteral(); + } else if (jj_2_484(2)) { + e = CompoundIdentifier(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + intervalQualifier = IntervalQualifierStart(); + if (sign == -1) { + e = SqlStdOperatorTable.UNARY_MINUS.createCall(e.getParserPosition(), e); + } + {if (true) return SqlStdOperatorTable.INTERVAL.createCall(s.end(this), e, + intervalQualifier);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Year() throws ParseException { + if (jj_2_487(2)) { + jj_consume_token(YEAR); + {if (true) return TimeUnit.YEAR;} + } else if (jj_2_488(2)) { + jj_consume_token(YEARS); + {if (true) return warn(TimeUnit.YEAR);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Month() throws ParseException { + if (jj_2_489(2)) { + jj_consume_token(MONTH); + {if (true) return TimeUnit.MONTH;} + } else if (jj_2_490(2)) { + jj_consume_token(MONTHS); + {if (true) return warn(TimeUnit.MONTH);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Day() throws ParseException { + if (jj_2_491(2)) { + jj_consume_token(DAY); + {if (true) return TimeUnit.DAY;} + } else if (jj_2_492(2)) { + jj_consume_token(DAYS); + {if (true) return warn(TimeUnit.DAY);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Hour() throws ParseException { + if (jj_2_493(2)) { + jj_consume_token(HOUR); + {if (true) return TimeUnit.HOUR;} + } else if (jj_2_494(2)) { + jj_consume_token(HOURS); + {if (true) return warn(TimeUnit.HOUR);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Minute() throws ParseException { + if (jj_2_495(2)) { + jj_consume_token(MINUTE); + {if (true) return TimeUnit.MINUTE;} + } else if (jj_2_496(2)) { + jj_consume_token(MINUTES); + {if (true) return warn(TimeUnit.MINUTE);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit Second() throws ParseException { + if (jj_2_497(2)) { + jj_consume_token(SECOND); + {if (true) return TimeUnit.SECOND;} + } else if (jj_2_498(2)) { + jj_consume_token(SECONDS); + {if (true) return warn(TimeUnit.SECOND);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlIntervalQualifier IntervalQualifier() throws ParseException { + final Span s; + final TimeUnit start; + TimeUnit end = null; + int startPrec = RelDataType.PRECISION_NOT_SPECIFIED; + int secondFracPrec = RelDataType.PRECISION_NOT_SPECIFIED; + if (jj_2_512(2)) { + start = Year(); + s = span(); + startPrec = PrecisionOpt(); + if (jj_2_499(2)) { + jj_consume_token(TO); + end = Month(); + } else { + ; + } + } else if (jj_2_513(2)) { + start = Month(); + s = span(); + startPrec = PrecisionOpt(); + } else if (jj_2_514(2)) { + start = Day(); + s = span(); + startPrec = PrecisionOpt(); + if (jj_2_503(2)) { + jj_consume_token(TO); + if (jj_2_500(2)) { + end = Hour(); + } else if (jj_2_501(2)) { + end = Minute(); + } else if (jj_2_502(2)) { + end = Second(); + secondFracPrec = PrecisionOpt(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + } else if (jj_2_515(2)) { + start = Hour(); + s = span(); + startPrec = PrecisionOpt(); + if (jj_2_507(2)) { + jj_consume_token(TO); + if (jj_2_505(2)) { + end = Minute(); + } else if (jj_2_506(2)) { + end = Second(); + if (jj_2_504(2)) { + jj_consume_token(LPAREN); + secondFracPrec = UnsignedIntLiteral(); + jj_consume_token(RPAREN); + } else { + ; + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + } else if (jj_2_516(2)) { + start = Minute(); + s = span(); + startPrec = PrecisionOpt(); + if (jj_2_509(2)) { + jj_consume_token(TO); + end = Second(); + if (jj_2_508(2)) { + jj_consume_token(LPAREN); + secondFracPrec = UnsignedIntLiteral(); + jj_consume_token(RPAREN); + } else { + ; + } + } else { + ; + } + } else if (jj_2_517(2)) { + start = Second(); + s = span(); + if (jj_2_511(2)) { + jj_consume_token(LPAREN); + startPrec = UnsignedIntLiteral(); + if (jj_2_510(2)) { + jj_consume_token(COMMA); + secondFracPrec = UnsignedIntLiteral(); + } else { + ; + } + jj_consume_token(RPAREN); + } else { + ; + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlIntervalQualifier(start, startPrec, end, secondFracPrec, + s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** Interval qualifier without 'TO unit'. */ + final public SqlIntervalQualifier IntervalQualifierStart() throws ParseException { + final Span s; + final TimeUnit start; + int startPrec = RelDataType.PRECISION_NOT_SPECIFIED; + int secondFracPrec = RelDataType.PRECISION_NOT_SPECIFIED; + if (jj_2_525(2)) { + if (jj_2_518(2)) { + start = Year(); + } else if (jj_2_519(2)) { + start = Month(); + } else if (jj_2_520(2)) { + start = Day(); + } else if (jj_2_521(2)) { + start = Hour(); + } else if (jj_2_522(2)) { + start = Minute(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + startPrec = PrecisionOpt(); + } else if (jj_2_526(2)) { + start = Second(); + s = span(); + if (jj_2_524(2)) { + jj_consume_token(LPAREN); + startPrec = UnsignedIntLiteral(); + if (jj_2_523(2)) { + jj_consume_token(COMMA); + secondFracPrec = UnsignedIntLiteral(); + } else { + ; + } + jj_consume_token(RPAREN); + } else { + ; + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlIntervalQualifier(start, startPrec, null, secondFracPrec, + s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** + * Parses time unit for EXTRACT, CEIL and FLOOR functions. + * Note that it does't include NANOSECOND and MICROSECOND. + */ + final public TimeUnit TimeUnit() throws ParseException { + if (jj_2_527(2)) { + jj_consume_token(MILLISECOND); + {if (true) return TimeUnit.MILLISECOND;} + } else if (jj_2_528(2)) { + jj_consume_token(SECOND); + {if (true) return TimeUnit.SECOND;} + } else if (jj_2_529(2)) { + jj_consume_token(MINUTE); + {if (true) return TimeUnit.MINUTE;} + } else if (jj_2_530(2)) { + jj_consume_token(HOUR); + {if (true) return TimeUnit.HOUR;} + } else if (jj_2_531(2)) { + jj_consume_token(DAY); + {if (true) return TimeUnit.DAY;} + } else if (jj_2_532(2)) { + jj_consume_token(DOW); + {if (true) return TimeUnit.DOW;} + } else if (jj_2_533(2)) { + jj_consume_token(DOY); + {if (true) return TimeUnit.DOY;} + } else if (jj_2_534(2)) { + jj_consume_token(ISODOW); + {if (true) return TimeUnit.ISODOW;} + } else if (jj_2_535(2)) { + jj_consume_token(ISOYEAR); + {if (true) return TimeUnit.ISOYEAR;} + } else if (jj_2_536(2)) { + jj_consume_token(WEEK); + {if (true) return TimeUnit.WEEK;} + } else if (jj_2_537(2)) { + jj_consume_token(MONTH); + {if (true) return TimeUnit.MONTH;} + } else if (jj_2_538(2)) { + jj_consume_token(QUARTER); + {if (true) return TimeUnit.QUARTER;} + } else if (jj_2_539(2)) { + jj_consume_token(YEAR); + {if (true) return TimeUnit.YEAR;} + } else if (jj_2_540(2)) { + jj_consume_token(EPOCH); + {if (true) return TimeUnit.EPOCH;} + } else if (jj_2_541(2)) { + jj_consume_token(DECADE); + {if (true) return TimeUnit.DECADE;} + } else if (jj_2_542(2)) { + jj_consume_token(CENTURY); + {if (true) return TimeUnit.CENTURY;} + } else if (jj_2_543(2)) { + jj_consume_token(MILLENNIUM); + {if (true) return TimeUnit.MILLENNIUM;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public TimeUnit TimestampInterval() throws ParseException { + if (jj_2_544(2)) { + jj_consume_token(FRAC_SECOND); + {if (true) return TimeUnit.MICROSECOND;} + } else if (jj_2_545(2)) { + jj_consume_token(MICROSECOND); + {if (true) return TimeUnit.MICROSECOND;} + } else if (jj_2_546(2)) { + jj_consume_token(NANOSECOND); + {if (true) return TimeUnit.NANOSECOND;} + } else if (jj_2_547(2)) { + jj_consume_token(SQL_TSI_FRAC_SECOND); + {if (true) return TimeUnit.NANOSECOND;} + } else if (jj_2_548(2)) { + jj_consume_token(SQL_TSI_MICROSECOND); + {if (true) return TimeUnit.MICROSECOND;} + } else if (jj_2_549(2)) { + jj_consume_token(SECOND); + {if (true) return TimeUnit.SECOND;} + } else if (jj_2_550(2)) { + jj_consume_token(SQL_TSI_SECOND); + {if (true) return TimeUnit.SECOND;} + } else if (jj_2_551(2)) { + jj_consume_token(MINUTE); + {if (true) return TimeUnit.MINUTE;} + } else if (jj_2_552(2)) { + jj_consume_token(SQL_TSI_MINUTE); + {if (true) return TimeUnit.MINUTE;} + } else if (jj_2_553(2)) { + jj_consume_token(HOUR); + {if (true) return TimeUnit.HOUR;} + } else if (jj_2_554(2)) { + jj_consume_token(SQL_TSI_HOUR); + {if (true) return TimeUnit.HOUR;} + } else if (jj_2_555(2)) { + jj_consume_token(DAY); + {if (true) return TimeUnit.DAY;} + } else if (jj_2_556(2)) { + jj_consume_token(SQL_TSI_DAY); + {if (true) return TimeUnit.DAY;} + } else if (jj_2_557(2)) { + jj_consume_token(WEEK); + {if (true) return TimeUnit.WEEK;} + } else if (jj_2_558(2)) { + jj_consume_token(SQL_TSI_WEEK); + {if (true) return TimeUnit.WEEK;} + } else if (jj_2_559(2)) { + jj_consume_token(MONTH); + {if (true) return TimeUnit.MONTH;} + } else if (jj_2_560(2)) { + jj_consume_token(SQL_TSI_MONTH); + {if (true) return TimeUnit.MONTH;} + } else if (jj_2_561(2)) { + jj_consume_token(QUARTER); + {if (true) return TimeUnit.QUARTER;} + } else if (jj_2_562(2)) { + jj_consume_token(SQL_TSI_QUARTER); + {if (true) return TimeUnit.QUARTER;} + } else if (jj_2_563(2)) { + jj_consume_token(YEAR); + {if (true) return TimeUnit.YEAR;} + } else if (jj_2_564(2)) { + jj_consume_token(SQL_TSI_YEAR); + {if (true) return TimeUnit.YEAR;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a dynamic parameter marker. + */ + final public SqlDynamicParam DynamicParam() throws ParseException { + jj_consume_token(HOOK); + {if (true) return new SqlDynamicParam(nDynamicParams++, getPos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses one segment of an identifier that may be composite. + * + *

Each time it reads an identifier it writes one element to each list; + * the entry in {@code positions} records its position and whether the + * segment was quoted. + */ + final public void IdentifierSegment(List names, List positions) throws ParseException { + final String id; + char unicodeEscapeChar = BACKSLASH; + final SqlParserPos pos; + final Span span; + if (jj_2_566(2)) { + jj_consume_token(IDENTIFIER); + id = unquotedIdentifier(); + pos = getPos(); + } else if (jj_2_567(2)) { + jj_consume_token(HYPHENATED_IDENTIFIER); + id = unquotedIdentifier(); + pos = getPos(); + } else if (jj_2_568(2)) { + jj_consume_token(QUOTED_IDENTIFIER); + id = SqlParserUtil.stripQuotes(getToken(0).image, DQ, DQ, DQDQ, + quotedCasing); + pos = getPos().withQuoting(true); + } else if (jj_2_569(2)) { + jj_consume_token(BACK_QUOTED_IDENTIFIER); + id = SqlParserUtil.stripQuotes(getToken(0).image, "`", "`", "``", + quotedCasing); + pos = getPos().withQuoting(true); + } else if (jj_2_570(2)) { + jj_consume_token(BIG_QUERY_BACK_QUOTED_IDENTIFIER); + id = SqlParserUtil.stripQuotes(getToken(0).image, "`", "`", "\\`", + quotedCasing); + pos = getPos().withQuoting(true); + } else if (jj_2_571(2)) { + jj_consume_token(BRACKET_QUOTED_IDENTIFIER); + id = SqlParserUtil.stripQuotes(getToken(0).image, "[", "]", "]]", + quotedCasing); + pos = getPos().withQuoting(true); + } else if (jj_2_572(2)) { + jj_consume_token(UNICODE_QUOTED_IDENTIFIER); + span = span(); + String image = getToken(0).image; + image = image.substring(image.indexOf('"')); + image = SqlParserUtil.stripQuotes(image, DQ, DQ, DQDQ, quotedCasing); + if (jj_2_565(2)) { + jj_consume_token(UESCAPE); + jj_consume_token(QUOTED_STRING); + String s = SqlParserUtil.parseString(token.image); + unicodeEscapeChar = SqlParserUtil.checkUnicodeEscapeChar(s); + } else { + ; + } + pos = span.end(this).withQuoting(true); + SqlLiteral lit = SqlLiteral.createCharString(image, "UTF16", pos); + lit = lit.unescapeUnicode(unicodeEscapeChar); + id = lit.toValue(); + } else if (jj_2_573(2)) { + id = NonReservedKeyWord(); + pos = getPos(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (id.length() > this.identifierMaxLength) { + {if (true) throw SqlUtil.newContextException(pos, + RESOURCE.identifierTooLong(id, this.identifierMaxLength));} + } + names.add(id); + if (positions != null) { + positions.add(pos); + } + } + +/** As {@link #IdentifierSegment} but part of a table name (for example, + * following {@code FROM}, {@code INSERT} or {@code UPDATE}). + * + *

In some dialects the lexical rules for table names are different from + * for other identifiers. For example, in BigQuery, table names may contain + * hyphens. */ + final public void TableIdentifierSegment(List names, List positions) throws ParseException { + IdentifierSegment(names, positions); + final int n = names.size(); + if (n > 0 + && positions.size() == n + && names.get(n - 1).contains(".") + && positions.get(n - 1).isQuoted() + && this.conformance.splitQuotedTableName()) { + final String name = names.remove(n - 1); + final SqlParserPos pos = positions.remove(n - 1); + final String[] splitNames = name.split("\\."); + for (String splitName : splitNames) { + names.add(splitName); + positions.add(pos); + } + } + } + +/** + * Parses a simple identifier as a String. + */ + final public String Identifier() throws ParseException { + final List names = new ArrayList(); + IdentifierSegment(names, null); + {if (true) return names.get(0);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a simple identifier as an SqlIdentifier. + */ + final public SqlIdentifier SimpleIdentifier() throws ParseException { + final List names = new ArrayList(); + final List positions = new ArrayList(); + IdentifierSegment(names, positions); + {if (true) return new SqlIdentifier(names.get(0), positions.get(0));} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a character literal as an SqlIdentifier. + * Only valid for column aliases in certain dialects. + */ + final public SqlIdentifier SimpleIdentifierFromStringLiteral() throws ParseException { + jj_consume_token(QUOTED_STRING); + if (!this.conformance.allowCharLiteralAlias()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.charLiteralAliasNotValid());} + } + final String s = SqlParserUtil.parseString(token.image); + {if (true) return new SqlIdentifier(s, getPos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a comma-separated list of simple identifiers. + */ + final public void SimpleIdentifierCommaList(List list) throws ParseException { + SqlIdentifier id; + id = SimpleIdentifier(); + list.add(id); + label_44: + while (true) { + if (jj_2_574(2)) { + ; + } else { + break label_44; + } + jj_consume_token(COMMA); + id = SimpleIdentifier(); + list.add(id); + } + } + +/** + * List of simple identifiers in parentheses. The position extends from the + * open parenthesis to the close parenthesis. + */ + final public SqlNodeList ParenthesizedSimpleIdentifierList() throws ParseException { + final Span s; + final List list = new ArrayList(); + jj_consume_token(LPAREN); + s = span(); + SimpleIdentifierCommaList(list); + jj_consume_token(RPAREN); + {if (true) return new SqlNodeList(list, s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** List of simple identifiers in parentheses or one simple identifier. + * + *

    Examples: + *
  • {@code DEPTNO} + *
  • {@code (EMPNO, DEPTNO)} + *
+ */ + final public SqlNodeList SimpleIdentifierOrList() throws ParseException { + SqlIdentifier id; + SqlNodeList list; + if (jj_2_575(2)) { + id = SimpleIdentifier(); + {if (true) return new SqlNodeList(Collections.singletonList(id), id.getParserPosition());} + } else if (jj_2_576(2)) { + list = ParenthesizedSimpleIdentifierList(); + {if (true) return list;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a compound identifier. + */ + final public SqlIdentifier CompoundIdentifier() throws ParseException { + final List nameList = new ArrayList(); + final List posList = new ArrayList(); + boolean star = false; + IdentifierSegment(nameList, posList); + label_45: + while (true) { + if (jj_2_577(2)) { + ; + } else { + break label_45; + } + jj_consume_token(DOT); + IdentifierSegment(nameList, posList); + } + if (jj_2_578(2)) { + jj_consume_token(DOT); + jj_consume_token(STAR); + star = true; + nameList.add(""); + posList.add(getPos()); + } else { + ; + } + SqlParserPos pos = SqlParserPos.sum(posList); + if (star) { + {if (true) return SqlIdentifier.star(nameList, pos, posList);} + } + {if (true) return new SqlIdentifier(nameList, null, pos, posList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a compound identifier in the FROM clause. + */ + final public SqlIdentifier CompoundTableIdentifier() throws ParseException { + final List nameList = new ArrayList(); + final List posList = new ArrayList(); + TableIdentifierSegment(nameList, posList); + label_46: + while (true) { + if (jj_2_579(2)) { + ; + } else { + break label_46; + } + jj_consume_token(DOT); + TableIdentifierSegment(nameList, posList); + } + SqlParserPos pos = SqlParserPos.sum(posList); + {if (true) return new SqlIdentifier(nameList, null, pos, posList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a comma-separated list of compound identifiers. + */ + final public void CompoundIdentifierTypeCommaList(List list, List extendList) throws ParseException { + CompoundIdentifierType(list, extendList); + label_47: + while (true) { + if (jj_2_580(2)) { + ; + } else { + break label_47; + } + jj_consume_token(COMMA); + CompoundIdentifierType(list, extendList); + } + } + +/** + * List of compound identifiers in parentheses. The position extends from the + * open parenthesis to the close parenthesis. + */ + final public Pair ParenthesizedCompoundIdentifierList() throws ParseException { + final Span s; + final List list = new ArrayList(); + final List extendList = new ArrayList(); + jj_consume_token(LPAREN); + s = span(); + CompoundIdentifierTypeCommaList(list, extendList); + jj_consume_token(RPAREN); + {if (true) return Pair.of(new SqlNodeList(list, s.end(this)), new SqlNodeList(extendList, s.end(this)));} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a NEW UDT(...) expression. + */ + final public SqlNode NewSpecification() throws ParseException { + final Span s; + final SqlNode routineCall; + jj_consume_token(NEW); + s = span(); + routineCall = NamedRoutineCall(SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR, + ExprContext.ACCEPT_SUB_QUERY); + {if (true) return SqlStdOperatorTable.NEW.createCall(s.end(routineCall), routineCall);} + throw new Error("Missing return statement in function"); + } + +//TODO: real parse errors. + final public int UnsignedIntLiteral() throws ParseException { + Token t; + t = jj_consume_token(UNSIGNED_INTEGER_LITERAL); + try { + {if (true) return Integer.parseInt(t.image);} + } catch (NumberFormatException ex) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));} + } + throw new Error("Missing return statement in function"); + } + + final public int IntLiteral() throws ParseException { + Token t; + if (jj_2_583(2)) { + if (jj_2_581(2)) { + t = jj_consume_token(UNSIGNED_INTEGER_LITERAL); + } else if (jj_2_582(2)) { + jj_consume_token(PLUS); + t = jj_consume_token(UNSIGNED_INTEGER_LITERAL); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + try { + {if (true) return Integer.parseInt(t.image);} + } catch (NumberFormatException ex) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));} + } + } else if (jj_2_584(2)) { + jj_consume_token(MINUS); + t = jj_consume_token(UNSIGNED_INTEGER_LITERAL); + try { + {if (true) return -Integer.parseInt(t.image);} + } catch (NumberFormatException ex) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +// Type name with optional scale and precision. + final public SqlDataTypeSpec DataType() throws ParseException { + SqlTypeNameSpec typeName; + final Span s; + typeName = TypeName(); + s = Span.of(typeName.getParserPos()); + label_48: + while (true) { + if (jj_2_585(2)) { + ; + } else { + break label_48; + } + typeName = CollectionsTypeName(typeName); + } + {if (true) return new SqlDataTypeSpec(typeName, s.add(typeName.getParserPos()).pos());} + throw new Error("Missing return statement in function"); + } + +// Some SQL type names need special handling due to the fact that they have +// spaces in them but are not quoted. + final public SqlTypeNameSpec TypeName() throws ParseException { + final SqlTypeNameSpec typeNameSpec; + final SqlIdentifier typeName; + final Span s = Span.of(); + if (jj_2_586(2)) { + typeNameSpec = SqlTypeName(s); + } else if (jj_2_587(2)) { + typeNameSpec = RowTypeName(); + } else if (jj_2_588(2)) { + typeName = CompoundIdentifier(); + typeNameSpec = new SqlUserDefinedTypeNameSpec(typeName, s.end(this)); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return typeNameSpec;} + throw new Error("Missing return statement in function"); + } + +// Types used for JDBC and ODBC scalar conversion function + final public SqlTypeNameSpec SqlTypeName(Span s) throws ParseException { + final SqlTypeNameSpec sqlTypeNameSpec; + if (jj_2_589(2)) { + sqlTypeNameSpec = SqlTypeName1(s); + } else if (jj_2_590(2)) { + sqlTypeNameSpec = SqlTypeName2(s); + } else if (jj_2_591(2)) { + sqlTypeNameSpec = SqlTypeName3(s); + } else if (jj_2_592(2)) { + sqlTypeNameSpec = CharacterTypeName(s); + } else if (jj_2_593(2)) { + sqlTypeNameSpec = DateTimeTypeName(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return sqlTypeNameSpec;} + throw new Error("Missing return statement in function"); + } + +// Parse sql type name that don't allow any extra specifications except the type name. +// For extra specification, we mean precision, scale, charSet, etc. + final public SqlTypeNameSpec SqlTypeName1(Span s) throws ParseException { + final SqlTypeName sqlTypeName; + if (jj_2_597(2)) { + jj_consume_token(GEOMETRY); + if (!this.conformance.allowGeometry()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.geometryDisabled());} + } + s.add(this); + sqlTypeName = SqlTypeName.GEOMETRY; + } else if (jj_2_598(2)) { + jj_consume_token(BOOLEAN); + s.add(this); sqlTypeName = SqlTypeName.BOOLEAN; + } else if (jj_2_599(2)) { + if (jj_2_594(2)) { + jj_consume_token(INTEGER); + } else if (jj_2_595(2)) { + jj_consume_token(INT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s.add(this); sqlTypeName = SqlTypeName.INTEGER; + } else if (jj_2_600(2)) { + jj_consume_token(TINYINT); + s.add(this); sqlTypeName = SqlTypeName.TINYINT; + } else if (jj_2_601(2)) { + jj_consume_token(SMALLINT); + s.add(this); sqlTypeName = SqlTypeName.SMALLINT; + } else if (jj_2_602(2)) { + jj_consume_token(BIGINT); + s.add(this); sqlTypeName = SqlTypeName.BIGINT; + } else if (jj_2_603(2)) { + jj_consume_token(REAL); + s.add(this); sqlTypeName = SqlTypeName.REAL; + } else if (jj_2_604(2)) { + jj_consume_token(DOUBLE); + s.add(this); + if (jj_2_596(2)) { + jj_consume_token(PRECISION); + } else { + ; + } + sqlTypeName = SqlTypeName.DOUBLE; + } else if (jj_2_605(2)) { + jj_consume_token(FLOAT); + s.add(this); sqlTypeName = SqlTypeName.FLOAT; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlBasicTypeNameSpec(sqlTypeName, s.end(this));} + throw new Error("Missing return statement in function"); + } + +// Parse sql type name that allows precision specification. + final public SqlTypeNameSpec SqlTypeName2(Span s) throws ParseException { + final SqlTypeName sqlTypeName; + int precision = -1; + if (jj_2_607(2)) { + jj_consume_token(BINARY); + s.add(this); + if (jj_2_606(2)) { + jj_consume_token(VARYING); + sqlTypeName = SqlTypeName.VARBINARY; + } else { + sqlTypeName = SqlTypeName.BINARY; + } + } else if (jj_2_608(2)) { + jj_consume_token(VARBINARY); + s.add(this); sqlTypeName = SqlTypeName.VARBINARY; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + precision = PrecisionOpt(); + {if (true) return new SqlBasicTypeNameSpec(sqlTypeName, precision, s.end(this));} + throw new Error("Missing return statement in function"); + } + +// Parse sql type name that allows precision and scale specifications. + final public SqlTypeNameSpec SqlTypeName3(Span s) throws ParseException { + final SqlTypeName sqlTypeName; + int precision = -1; + int scale = -1; + if (jj_2_612(2)) { + if (jj_2_609(2)) { + jj_consume_token(DECIMAL); + } else if (jj_2_610(2)) { + jj_consume_token(DEC); + } else if (jj_2_611(2)) { + jj_consume_token(NUMERIC); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s.add(this); sqlTypeName = SqlTypeName.DECIMAL; + } else if (jj_2_613(2)) { + jj_consume_token(ANY); + s.add(this); sqlTypeName = SqlTypeName.ANY; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_615(2)) { + jj_consume_token(LPAREN); + precision = UnsignedIntLiteral(); + if (jj_2_614(2)) { + jj_consume_token(COMMA); + scale = UnsignedIntLiteral(); + } else { + ; + } + jj_consume_token(RPAREN); + } else { + ; + } + {if (true) return new SqlBasicTypeNameSpec(sqlTypeName, precision, scale, s.end(this));} + throw new Error("Missing return statement in function"); + } + +// Types used for for JDBC and ODBC scalar conversion function + final public SqlJdbcDataTypeName JdbcOdbcDataTypeName() throws ParseException { + if (jj_2_650(2)) { + if (jj_2_616(2)) { + jj_consume_token(SQL_CHAR); + } else if (jj_2_617(2)) { + jj_consume_token(CHAR); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_CHAR;} + } else if (jj_2_651(2)) { + if (jj_2_618(2)) { + jj_consume_token(SQL_VARCHAR); + } else if (jj_2_619(2)) { + jj_consume_token(VARCHAR); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_VARCHAR;} + } else if (jj_2_652(2)) { + if (jj_2_620(2)) { + jj_consume_token(SQL_DATE); + } else if (jj_2_621(2)) { + jj_consume_token(DATE); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_DATE;} + } else if (jj_2_653(2)) { + if (jj_2_622(2)) { + jj_consume_token(SQL_TIME); + } else if (jj_2_623(2)) { + jj_consume_token(TIME); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_TIME;} + } else if (jj_2_654(2)) { + if (jj_2_624(2)) { + jj_consume_token(SQL_TIMESTAMP); + } else if (jj_2_625(2)) { + jj_consume_token(TIMESTAMP); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_TIMESTAMP;} + } else if (jj_2_655(2)) { + if (jj_2_626(2)) { + jj_consume_token(SQL_DECIMAL); + } else if (jj_2_627(2)) { + jj_consume_token(DECIMAL); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_DECIMAL;} + } else if (jj_2_656(2)) { + if (jj_2_628(2)) { + jj_consume_token(SQL_NUMERIC); + } else if (jj_2_629(2)) { + jj_consume_token(NUMERIC); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_NUMERIC;} + } else if (jj_2_657(2)) { + if (jj_2_630(2)) { + jj_consume_token(SQL_BOOLEAN); + } else if (jj_2_631(2)) { + jj_consume_token(BOOLEAN); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_BOOLEAN;} + } else if (jj_2_658(2)) { + if (jj_2_632(2)) { + jj_consume_token(SQL_INTEGER); + } else if (jj_2_633(2)) { + jj_consume_token(INTEGER); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_INTEGER;} + } else if (jj_2_659(2)) { + if (jj_2_634(2)) { + jj_consume_token(SQL_BINARY); + } else if (jj_2_635(2)) { + jj_consume_token(BINARY); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_BINARY;} + } else if (jj_2_660(2)) { + if (jj_2_636(2)) { + jj_consume_token(SQL_VARBINARY); + } else if (jj_2_637(2)) { + jj_consume_token(VARBINARY); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_VARBINARY;} + } else if (jj_2_661(2)) { + if (jj_2_638(2)) { + jj_consume_token(SQL_TINYINT); + } else if (jj_2_639(2)) { + jj_consume_token(TINYINT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_TINYINT;} + } else if (jj_2_662(2)) { + if (jj_2_640(2)) { + jj_consume_token(SQL_SMALLINT); + } else if (jj_2_641(2)) { + jj_consume_token(SMALLINT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_SMALLINT;} + } else if (jj_2_663(2)) { + if (jj_2_642(2)) { + jj_consume_token(SQL_BIGINT); + } else if (jj_2_643(2)) { + jj_consume_token(BIGINT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_BIGINT;} + } else if (jj_2_664(2)) { + if (jj_2_644(2)) { + jj_consume_token(SQL_REAL); + } else if (jj_2_645(2)) { + jj_consume_token(REAL); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_REAL;} + } else if (jj_2_665(2)) { + if (jj_2_646(2)) { + jj_consume_token(SQL_DOUBLE); + } else if (jj_2_647(2)) { + jj_consume_token(DOUBLE); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_DOUBLE;} + } else if (jj_2_666(2)) { + if (jj_2_648(2)) { + jj_consume_token(SQL_FLOAT); + } else if (jj_2_649(2)) { + jj_consume_token(FLOAT); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlJdbcDataTypeName.SQL_FLOAT;} + } else if (jj_2_667(2)) { + jj_consume_token(SQL_INTERVAL_YEAR); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_YEAR;} + } else if (jj_2_668(2)) { + jj_consume_token(SQL_INTERVAL_YEAR_TO_MONTH); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_YEAR_TO_MONTH;} + } else if (jj_2_669(2)) { + jj_consume_token(SQL_INTERVAL_MONTH); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_MONTH;} + } else if (jj_2_670(2)) { + jj_consume_token(SQL_INTERVAL_DAY); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_DAY;} + } else if (jj_2_671(2)) { + jj_consume_token(SQL_INTERVAL_DAY_TO_HOUR); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_HOUR;} + } else if (jj_2_672(2)) { + jj_consume_token(SQL_INTERVAL_DAY_TO_MINUTE); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_MINUTE;} + } else if (jj_2_673(2)) { + jj_consume_token(SQL_INTERVAL_DAY_TO_SECOND); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_SECOND;} + } else if (jj_2_674(2)) { + jj_consume_token(SQL_INTERVAL_HOUR); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR;} + } else if (jj_2_675(2)) { + jj_consume_token(SQL_INTERVAL_HOUR_TO_MINUTE); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR_TO_MINUTE;} + } else if (jj_2_676(2)) { + jj_consume_token(SQL_INTERVAL_HOUR_TO_SECOND); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR_TO_SECOND;} + } else if (jj_2_677(2)) { + jj_consume_token(SQL_INTERVAL_MINUTE); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_MINUTE;} + } else if (jj_2_678(2)) { + jj_consume_token(SQL_INTERVAL_MINUTE_TO_SECOND); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_MINUTE_TO_SECOND;} + } else if (jj_2_679(2)) { + jj_consume_token(SQL_INTERVAL_SECOND); + {if (true) return SqlJdbcDataTypeName.SQL_INTERVAL_SECOND;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlLiteral JdbcOdbcDataType() throws ParseException { + SqlJdbcDataTypeName typeName; + typeName = JdbcOdbcDataTypeName(); + {if (true) return typeName.symbol(getPos());} + throw new Error("Missing return statement in function"); + } + +/** +* Parse a collection type name, the input element type name may +* also be a collection type. +*/ + final public SqlTypeNameSpec CollectionsTypeName(SqlTypeNameSpec elementTypeName) throws ParseException { + final SqlTypeName collectionTypeName; + if (jj_2_680(2)) { + jj_consume_token(MULTISET); + collectionTypeName = SqlTypeName.MULTISET; + } else if (jj_2_681(2)) { + jj_consume_token(ARRAY); + collectionTypeName = SqlTypeName.ARRAY; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlCollectionTypeNameSpec(elementTypeName, + collectionTypeName, getPos());} + throw new Error("Missing return statement in function"); + } + +/** +* Parse a nullable option, default is true. +*/ + final public boolean NullableOptDefaultTrue() throws ParseException { + if (jj_2_682(2)) { + jj_consume_token(NULL); + {if (true) return true;} + } else if (jj_2_683(2)) { + jj_consume_token(NOT); + jj_consume_token(NULL); + {if (true) return false;} + } else { + {if (true) return true;} + } + throw new Error("Missing return statement in function"); + } + +/** +* Parse a nullable option, default is false. +*/ + final public boolean NullableOptDefaultFalse() throws ParseException { + if (jj_2_684(2)) { + jj_consume_token(NULL); + {if (true) return true;} + } else if (jj_2_685(2)) { + jj_consume_token(NOT); + jj_consume_token(NULL); + {if (true) return false;} + } else { + {if (true) return false;} + } + throw new Error("Missing return statement in function"); + } + +/** +* Parse a "name1 type1 [NULL | NOT NULL], name2 type2 [NULL | NOT NULL] ..." list, +* the field type default is not nullable. +*/ + final public void FieldNameTypeCommaList(List fieldNames, + List fieldTypes) throws ParseException { + SqlIdentifier fName; + SqlDataTypeSpec fType; + boolean nullable; + fName = SimpleIdentifier(); + fType = DataType(); + nullable = NullableOptDefaultFalse(); + fieldNames.add(fName); + fieldTypes.add(fType.withNullable(nullable, getPos())); + label_49: + while (true) { + if (jj_2_686(2)) { + ; + } else { + break label_49; + } + jj_consume_token(COMMA); + fName = SimpleIdentifier(); + fType = DataType(); + nullable = NullableOptDefaultFalse(); + fieldNames.add(fName); + fieldTypes.add(fType.withNullable(nullable, getPos())); + } + } + +/** +* Parse Row type with format: Row(name1 type1, name2 type2). +* Every field type can have suffix of `NULL` or `NOT NULL` to indicate if this type is nullable. +* i.e. Row(f0 int not null, f1 varchar null). +*/ + final public SqlTypeNameSpec RowTypeName() throws ParseException { + List fieldNames = new ArrayList(); + List fieldTypes = new ArrayList(); + jj_consume_token(ROW); + jj_consume_token(LPAREN); + FieldNameTypeCommaList(fieldNames, fieldTypes); + jj_consume_token(RPAREN); + {if (true) return new SqlRowTypeNameSpec(getPos(), fieldNames, fieldTypes);} + throw new Error("Missing return statement in function"); + } + +/** +* Parse character types: char, varchar. +*/ + final public SqlTypeNameSpec CharacterTypeName(Span s) throws ParseException { + int precision = -1; + final SqlTypeName sqlTypeName; + String charSetName = null; + if (jj_2_690(2)) { + if (jj_2_687(2)) { + jj_consume_token(CHARACTER); + } else if (jj_2_688(2)) { + jj_consume_token(CHAR); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s.add(this); + if (jj_2_689(2)) { + jj_consume_token(VARYING); + sqlTypeName = SqlTypeName.VARCHAR; + } else { + sqlTypeName = SqlTypeName.CHAR; + } + } else if (jj_2_691(2)) { + jj_consume_token(VARCHAR); + s.add(this); sqlTypeName = SqlTypeName.VARCHAR; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + precision = PrecisionOpt(); + if (jj_2_692(2)) { + jj_consume_token(CHARACTER); + jj_consume_token(SET); + charSetName = Identifier(); + } else { + ; + } + {if (true) return new SqlBasicTypeNameSpec(sqlTypeName, precision, charSetName, s.end(this));} + throw new Error("Missing return statement in function"); + } + +/** +* Parse datetime types: date, time, timestamp. +*/ + final public SqlTypeNameSpec DateTimeTypeName() throws ParseException { + int precision = -1; + SqlTypeName typeName; + boolean withLocalTimeZone = false; + final Span s; + if (jj_2_693(2)) { + jj_consume_token(DATE); + typeName = SqlTypeName.DATE; + {if (true) return new SqlBasicTypeNameSpec(typeName, getPos());} + } else if (jj_2_694(2)) { + jj_consume_token(TIME); + s = span(); + precision = PrecisionOpt(); + withLocalTimeZone = TimeZoneOpt(); + if (withLocalTimeZone) { + typeName = SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE; + } else { + typeName = SqlTypeName.TIME; + } + {if (true) return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));} + } else if (jj_2_695(2)) { + jj_consume_token(TIMESTAMP); + s = span(); + precision = PrecisionOpt(); + withLocalTimeZone = TimeZoneOpt(); + if (withLocalTimeZone) { + typeName = SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE; + } else { + typeName = SqlTypeName.TIMESTAMP; + } + {if (true) return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +// Parse an optional data type precision, default is -1. + final public int PrecisionOpt() throws ParseException { + int precision = -1; + if (jj_2_696(2)) { + jj_consume_token(LPAREN); + precision = UnsignedIntLiteral(); + jj_consume_token(RPAREN); + {if (true) return precision;} + } else { + {if (true) return -1;} + } + throw new Error("Missing return statement in function"); + } + +/** +* Parse a time zone suffix for DateTime types. According to SQL-2011, +* "with time zone" and "without time zone" belong to standard SQL but we +* only implement the "without time zone". +* +*

We also support "with local time zone". +* +* @return true if this is "with local time zone". +*/ + final public boolean TimeZoneOpt() throws ParseException { + if (jj_2_697(3)) { + jj_consume_token(WITHOUT); + jj_consume_token(TIME); + jj_consume_token(ZONE); + {if (true) return false;} + } else if (jj_2_698(2)) { + jj_consume_token(WITH); + jj_consume_token(LOCAL); + jj_consume_token(TIME); + jj_consume_token(ZONE); + {if (true) return true;} + } else { + {if (true) return false;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a CURSOR(query) expression. The parser allows these + * anywhere, but the validator restricts them to appear only as + * arguments to table functions. + */ + final public SqlNode CursorExpression(ExprContext exprContext) throws ParseException { + final SqlNode e; + final Span s; + jj_consume_token(CURSOR); + s = span(); + if (exprContext != ExprContext.ACCEPT_ALL + && exprContext != ExprContext.ACCEPT_CURSOR) { + {if (true) throw SqlUtil.newContextException(s.end(this), + RESOURCE.illegalCursorExpression());} + } + e = Expression(ExprContext.ACCEPT_QUERY); + {if (true) return SqlStdOperatorTable.CURSOR.createCall(s.end(e), e);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to a builtin function with special syntax. + */ + final public SqlNode BuiltinFunctionCall() throws ParseException { + final SqlIdentifier name; + List args = null; + SqlNode e = null; + final Span s; + SqlDataTypeSpec dt; + TimeUnit interval; + final TimeUnit unit; + final SqlNode node; + if (jj_2_724(2)) { + jj_consume_token(CAST); + s = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + jj_consume_token(AS); + if (jj_2_699(2)) { + dt = DataType(); + args.add(dt); + } else if (jj_2_700(2)) { + jj_consume_token(INTERVAL); + e = IntervalQualifier(); + args.add(e); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.CAST.createCall(s.end(this), args);} + } else if (jj_2_725(2)) { + jj_consume_token(EXTRACT); + s = span(); + jj_consume_token(LPAREN); + if (jj_2_701(2)) { + jj_consume_token(NANOSECOND); + unit = TimeUnit.NANOSECOND; + } else if (jj_2_702(2)) { + jj_consume_token(MICROSECOND); + unit = TimeUnit.MICROSECOND; + } else if (jj_2_703(2)) { + unit = TimeUnit(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + args = startList(new SqlIntervalQualifier(unit, null, getPos())); + jj_consume_token(FROM); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.EXTRACT.createCall(s.end(this), args);} + } else if (jj_2_726(2)) { + jj_consume_token(POSITION); + s = span(); + jj_consume_token(LPAREN); + // FIXME jvs 31-Aug-2006: FRG-192: This should be + // Expression(ExprContext.ACCEPT_SUB_QUERY), but that doesn't work + // because it matches the other kind of IN. + e = AtomicRowExpression(); + args = startList(e); + jj_consume_token(IN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + if (jj_2_704(2)) { + jj_consume_token(FROM); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.POSITION.createCall(s.end(this), args);} + } else if (jj_2_727(2)) { + jj_consume_token(CONVERT); + s = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + jj_consume_token(USING); + name = SimpleIdentifier(); + args.add(name); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.CONVERT.createCall(s.end(this), args);} + } else if (jj_2_728(2)) { + jj_consume_token(TRANSLATE); + s = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + if (jj_2_706(2)) { + jj_consume_token(USING); + name = SimpleIdentifier(); + args.add(name); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.TRANSLATE.createCall(s.end(this), + args);} + } else if (jj_2_707(2)) { + label_50: + while (true) { + if (jj_2_705(2)) { + ; + } else { + break label_50; + } + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + } + jj_consume_token(RPAREN); + {if (true) return SqlLibraryOperators.TRANSLATE3.createCall(s.end(this), + args);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_729(2)) { + jj_consume_token(OVERLAY); + s = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + jj_consume_token(PLACING); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(FROM); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + if (jj_2_708(2)) { + jj_consume_token(FOR); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.OVERLAY.createCall(s.end(this), args);} + } else if (jj_2_730(2)) { + jj_consume_token(FLOOR); + s = span(); + e = FloorCeilOptions(s, true); + {if (true) return e;} + } else if (jj_2_731(2)) { + if (jj_2_709(2)) { + jj_consume_token(CEIL); + } else if (jj_2_710(2)) { + jj_consume_token(CEILING); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + e = FloorCeilOptions(s, false); + {if (true) return e;} + } else if (jj_2_732(2)) { + jj_consume_token(SUBSTRING); + s = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + if (jj_2_711(2)) { + jj_consume_token(FROM); + } else if (jj_2_712(2)) { + jj_consume_token(COMMA); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + if (jj_2_715(2)) { + if (jj_2_713(2)) { + jj_consume_token(FOR); + } else if (jj_2_714(2)) { + jj_consume_token(COMMA); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.SUBSTRING.createCall( + s.end(this), args);} + } else if (jj_2_733(2)) { + jj_consume_token(TRIM); + SqlLiteral flag = null; + SqlNode trimChars = null; + s = span(); + jj_consume_token(LPAREN); + if (jj_2_723(2)) { + if (jj_2_719(2)) { + if (jj_2_716(2)) { + jj_consume_token(BOTH); + s.add(this); + flag = SqlTrimFunction.Flag.BOTH.symbol(getPos()); + } else if (jj_2_717(2)) { + jj_consume_token(TRAILING); + s.add(this); + flag = SqlTrimFunction.Flag.TRAILING.symbol(getPos()); + } else if (jj_2_718(2)) { + jj_consume_token(LEADING); + s.add(this); + flag = SqlTrimFunction.Flag.LEADING.symbol(getPos()); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + if (jj_2_720(2)) { + trimChars = Expression(ExprContext.ACCEPT_SUB_QUERY); + } else { + ; + } + if (jj_2_721(2)) { + jj_consume_token(FROM); + if (null == flag && null == trimChars) { + {if (true) throw SqlUtil.newContextException(getPos(), + RESOURCE.illegalFromEmpty());} + } + } else if (jj_2_722(2)) { + jj_consume_token(RPAREN); + // This is to handle the case of TRIM(x) + // (FRG-191). + if (flag == null) { + flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO); + } + args = startList(flag); + args.add(null); // no trim chars + args.add(trimChars); // reinterpret trimChars as source + {if (true) return SqlStdOperatorTable.TRIM.createCall(s.end(this), + args);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + if (flag == null) { + flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO); + } + args = startList(flag); + args.add(trimChars); + args.add(e); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.TRIM.createCall(s.end(this), args);} + } else if (jj_2_734(2)) { + node = TimestampAddFunctionCall(); + {if (true) return node;} + } else if (jj_2_735(2)) { + node = TimestampDiffFunctionCall(); + {if (true) return node;} + } else if (jj_2_736(2)) { + node = MatchRecognizeFunctionCall(); + {if (true) return node;} + } else if (jj_2_737(2)) { + node = JsonExistsFunctionCall(); + {if (true) return node;} + } else if (jj_2_738(2)) { + node = JsonValueFunctionCall(); + {if (true) return node;} + } else if (jj_2_739(2)) { + node = JsonQueryFunctionCall(); + {if (true) return node;} + } else if (jj_2_740(2)) { + node = JsonObjectFunctionCall(); + {if (true) return node;} + } else if (jj_2_741(2)) { + node = JsonObjectAggFunctionCall(); + {if (true) return node;} + } else if (jj_2_742(2)) { + node = JsonArrayFunctionCall(); + {if (true) return node;} + } else if (jj_2_743(2)) { + node = JsonArrayAggFunctionCall(); + {if (true) return node;} + } else if (jj_2_744(2)) { + node = GroupByWindowingCall(); + {if (true) return node;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlJsonEncoding JsonRepresentation() throws ParseException { + jj_consume_token(JSON); + if (jj_2_748(2)) { + jj_consume_token(ENCODING); + if (jj_2_745(2)) { + jj_consume_token(UTF8); + {if (true) return SqlJsonEncoding.UTF8;} + } else if (jj_2_746(2)) { + jj_consume_token(UTF16); + {if (true) return SqlJsonEncoding.UTF16;} + } else if (jj_2_747(2)) { + jj_consume_token(UTF32); + {if (true) return SqlJsonEncoding.UTF32;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return SqlJsonEncoding.UTF8;} + throw new Error("Missing return statement in function"); + } + + final public void JsonInputClause() throws ParseException { + jj_consume_token(FORMAT); + JsonRepresentation(); + } + + final public SqlDataTypeSpec JsonReturningClause() throws ParseException { + SqlDataTypeSpec dt; + jj_consume_token(RETURNING); + dt = DataType(); + {if (true) return dt;} + throw new Error("Missing return statement in function"); + } + + final public SqlDataTypeSpec JsonOutputClause() throws ParseException { + SqlDataTypeSpec dataType; + dataType = JsonReturningClause(); + if (jj_2_749(2)) { + jj_consume_token(FORMAT); + JsonRepresentation(); + } else { + ; + } + {if (true) return dataType;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode JsonPathSpec() throws ParseException { + SqlNode e; + e = StringLiteral(); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + + final public List JsonApiCommonSyntax() throws ParseException { + SqlNode e; + List args = new ArrayList(); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + args.add(e); + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + args.add(e); + if (jj_2_751(2)) { + jj_consume_token(PASSING); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + + jj_consume_token(AS); + e = SimpleIdentifier(); + + label_51: + while (true) { + if (jj_2_750(2)) { + ; + } else { + break label_51; + } + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + + jj_consume_token(AS); + e = SimpleIdentifier(); + + } + } else { + ; + } + {if (true) return args;} + throw new Error("Missing return statement in function"); + } + + final public SqlJsonExistsErrorBehavior JsonExistsErrorBehavior() throws ParseException { + if (jj_2_752(2)) { + jj_consume_token(TRUE); + {if (true) return SqlJsonExistsErrorBehavior.TRUE;} + } else if (jj_2_753(2)) { + jj_consume_token(FALSE); + {if (true) return SqlJsonExistsErrorBehavior.FALSE;} + } else if (jj_2_754(2)) { + jj_consume_token(UNKNOWN); + {if (true) return SqlJsonExistsErrorBehavior.UNKNOWN;} + } else if (jj_2_755(2)) { + jj_consume_token(ERROR); + {if (true) return SqlJsonExistsErrorBehavior.ERROR;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonExistsFunctionCall() throws ParseException { + List args = new ArrayList(); + List commonSyntax; + final Span span; + SqlJsonExistsErrorBehavior errorBehavior; + jj_consume_token(JSON_EXISTS); + span = span(); + jj_consume_token(LPAREN); + commonSyntax = JsonApiCommonSyntax(); + args.addAll(commonSyntax); + if (jj_2_756(2)) { + errorBehavior = JsonExistsErrorBehavior(); + args.add(errorBehavior.symbol(getPos())); + jj_consume_token(ON); + jj_consume_token(ERROR); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.JSON_EXISTS.createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public List JsonValueEmptyOrErrorBehavior() throws ParseException { + final List list = new ArrayList(); + final SqlNode e; + if (jj_2_757(2)) { + jj_consume_token(ERROR); + list.add(SqlJsonValueEmptyOrErrorBehavior.ERROR.symbol(getPos())); + } else if (jj_2_758(2)) { + jj_consume_token(NULL); + list.add(SqlJsonValueEmptyOrErrorBehavior.NULL.symbol(getPos())); + } else if (jj_2_759(2)) { + jj_consume_token(DEFAULT_); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + list.add(SqlJsonValueEmptyOrErrorBehavior.DEFAULT.symbol(getPos())); + list.add(e); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(ON); + if (jj_2_760(2)) { + jj_consume_token(EMPTY); + list.add(SqlJsonEmptyOrError.EMPTY.symbol(getPos())); + } else if (jj_2_761(2)) { + jj_consume_token(ERROR); + list.add(SqlJsonEmptyOrError.ERROR.symbol(getPos())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonValueFunctionCall() throws ParseException { + final List args = new ArrayList(7); + SqlNode e; + List commonSyntax; + final Span span; + List behavior; + jj_consume_token(JSON_VALUE); + span = span(); + jj_consume_token(LPAREN); + commonSyntax = JsonApiCommonSyntax(); + args.addAll(commonSyntax); + if (jj_2_762(2)) { + e = JsonReturningClause(); + args.add(SqlJsonValueReturning.RETURNING.symbol(getPos())); + args.add(e); + } else { + ; + } + label_52: + while (true) { + if (jj_2_763(2)) { + ; + } else { + break label_52; + } + behavior = JsonValueEmptyOrErrorBehavior(); + args.addAll(behavior); + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.JSON_VALUE.createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public List JsonQueryEmptyOrErrorBehavior() throws ParseException { + final List list = new ArrayList(); + SqlNode e; + if (jj_2_764(2)) { + jj_consume_token(ERROR); + list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.ERROR, getPos())); + } else if (jj_2_765(2)) { + jj_consume_token(NULL); + list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.NULL, getPos())); + } else if (jj_2_766(2)) { + jj_consume_token(EMPTY); + jj_consume_token(ARRAY); + list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.EMPTY_ARRAY, getPos())); + } else if (jj_2_767(2)) { + jj_consume_token(EMPTY); + jj_consume_token(OBJECT); + list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.EMPTY_OBJECT, getPos())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(ON); + if (jj_2_768(2)) { + jj_consume_token(EMPTY); + list.add(SqlLiteral.createSymbol(SqlJsonEmptyOrError.EMPTY, getPos())); + } else if (jj_2_769(2)) { + jj_consume_token(ERROR); + list.add(SqlLiteral.createSymbol(SqlJsonEmptyOrError.ERROR, getPos())); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode JsonQueryWrapperBehavior() throws ParseException { + SqlNode e; + if (jj_2_774(2)) { + jj_consume_token(WITHOUT); + if (jj_2_770(2)) { + jj_consume_token(ARRAY); + } else { + ; + } + {if (true) return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITHOUT_ARRAY, getPos());} + } else if (jj_2_775(2)) { + jj_consume_token(WITH); + jj_consume_token(CONDITIONAL); + if (jj_2_771(2)) { + jj_consume_token(ARRAY); + } else { + ; + } + {if (true) return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITH_CONDITIONAL_ARRAY, getPos());} + } else if (jj_2_776(2)) { + jj_consume_token(WITH); + if (jj_2_772(2)) { + jj_consume_token(UNCONDITIONAL); + } else { + ; + } + if (jj_2_773(2)) { + jj_consume_token(ARRAY); + } else { + ; + } + {if (true) return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITH_UNCONDITIONAL_ARRAY, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonQueryFunctionCall() throws ParseException { + final SqlNode[] args = new SqlNode[5]; + SqlNode e; + List commonSyntax; + final Span span; + List behavior; + jj_consume_token(JSON_QUERY); + span = span(); + jj_consume_token(LPAREN); + commonSyntax = JsonApiCommonSyntax(); + args[0] = commonSyntax.get(0); + args[1] = commonSyntax.get(1); + if (jj_2_777(2)) { + e = JsonQueryWrapperBehavior(); + jj_consume_token(WRAPPER); + args[2] = e; + } else { + ; + } + label_53: + while (true) { + if (jj_2_778(2)) { + ; + } else { + break label_53; + } + behavior = JsonQueryEmptyOrErrorBehavior(); + final SqlJsonEmptyOrError symbol = + ((SqlLiteral) behavior.get(1)).getValueAs(SqlJsonEmptyOrError.class); + switch (symbol) { + case EMPTY: + args[3] = behavior.get(0); + break; + case ERROR: + args[4] = behavior.get(0); + break; + } + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.JSON_QUERY.createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public SqlNode JsonName() throws ParseException { + final SqlNode e; + e = Expression(ExprContext.ACCEPT_NON_QUERY); + {if (true) return e;} + throw new Error("Missing return statement in function"); + } + + final public List JsonNameAndValue() throws ParseException { + final List list = new ArrayList(); + SqlNode e; + boolean kvMode = false; + if (jj_2_779(2)) { + jj_consume_token(KEY); + kvMode = true; + } else { + ; + } + e = JsonName(); + list.add(e); + if (jj_2_780(2)) { + jj_consume_token(VALUE); + } else if (jj_2_781(2)) { + jj_consume_token(COLON); + if (kvMode) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.illegalColon());} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + e = Expression(ExprContext.ACCEPT_NON_QUERY); + list.add(e); + {if (true) return list;} + throw new Error("Missing return statement in function"); + } + + final public SqlNode JsonConstructorNullClause() throws ParseException { + if (jj_2_782(2)) { + jj_consume_token(NULL); + jj_consume_token(ON); + jj_consume_token(NULL); + {if (true) return SqlLiteral.createSymbol(SqlJsonConstructorNullClause.NULL_ON_NULL, getPos());} + } else if (jj_2_783(2)) { + jj_consume_token(ABSENT); + jj_consume_token(ON); + jj_consume_token(NULL); + {if (true) return SqlLiteral.createSymbol(SqlJsonConstructorNullClause.ABSENT_ON_NULL, getPos());} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonObjectFunctionCall() throws ParseException { + final List nvArgs = new ArrayList(); + final SqlNode[] otherArgs = new SqlNode[1]; + SqlNode e; + List list; + final Span span; + jj_consume_token(JSON_OBJECT); + span = span(); + jj_consume_token(LPAREN); + if (jj_2_785(2)) { + list = JsonNameAndValue(); + nvArgs.addAll(list); + label_54: + while (true) { + if (jj_2_784(2)) { + ; + } else { + break label_54; + } + jj_consume_token(COMMA); + list = JsonNameAndValue(); + nvArgs.addAll(list); + } + } else { + ; + } + if (jj_2_786(2)) { + e = JsonConstructorNullClause(); + otherArgs[0] = e; + } else { + ; + } + jj_consume_token(RPAREN); + final List args = new ArrayList(); + args.addAll(Arrays.asList(otherArgs)); + args.addAll(nvArgs); + {if (true) return SqlStdOperatorTable.JSON_OBJECT.createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonObjectAggFunctionCall() throws ParseException { + final SqlNode[] args = new SqlNode[2]; + List list; + final Span span; + SqlJsonConstructorNullClause nullClause = + SqlJsonConstructorNullClause.NULL_ON_NULL; + final SqlNode e; + jj_consume_token(JSON_OBJECTAGG); + span = span(); + jj_consume_token(LPAREN); + list = JsonNameAndValue(); + args[0] = list.get(0); + args[1] = list.get(1); + if (jj_2_787(2)) { + e = JsonConstructorNullClause(); + nullClause = (SqlJsonConstructorNullClause) ((SqlLiteral) e).getValue(); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.JSON_OBJECTAGG.with(nullClause) + .createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonArrayFunctionCall() throws ParseException { + final List elements = new ArrayList(); + final SqlNode[] otherArgs = new SqlNode[1]; + SqlNode e; + final Span span; + jj_consume_token(JSON_ARRAY); + span = span(); + jj_consume_token(LPAREN); + if (jj_2_789(2)) { + e = Expression(ExprContext.ACCEPT_NON_QUERY); + elements.add(e); + label_55: + while (true) { + if (jj_2_788(2)) { + ; + } else { + break label_55; + } + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + elements.add(e); + } + } else { + ; + } + if (jj_2_790(2)) { + e = JsonConstructorNullClause(); + otherArgs[0] = e; + } else { + ; + } + jj_consume_token(RPAREN); + final List args = new ArrayList(); + args.addAll(Arrays.asList(otherArgs)); + args.addAll(elements); + {if (true) return SqlStdOperatorTable.JSON_ARRAY.createCall(span.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public SqlNodeList JsonArrayAggOrderByClause() throws ParseException { + final SqlNodeList orderList; + if (jj_2_791(2)) { + orderList = OrderBy(true); + } else { + orderList = null; + } + {if (true) return orderList;} + throw new Error("Missing return statement in function"); + } + + final public SqlCall JsonArrayAggFunctionCall() throws ParseException { + final SqlNode valueExpr; + final SqlNodeList orderList; + List list; + final Span span; + SqlJsonConstructorNullClause nullClause = + SqlJsonConstructorNullClause.ABSENT_ON_NULL; + SqlNode e = null; + final SqlNode aggCall; + jj_consume_token(JSON_ARRAYAGG); + span = span(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_NON_QUERY); + valueExpr = e; + orderList = JsonArrayAggOrderByClause(); + if (jj_2_792(2)) { + e = JsonConstructorNullClause(); + nullClause = (SqlJsonConstructorNullClause) ((SqlLiteral) e).getValue(); + } else { + ; + } + jj_consume_token(RPAREN); + aggCall = SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause) + .createCall(span.end(this), valueExpr, orderList); + if (jj_2_793(2)) { + e = withinGroup(aggCall); + if (orderList != null) { + {if (true) throw SqlUtil.newContextException(span.pos().plus(e.getParserPosition()), + RESOURCE.ambiguousSortOrderInJsonArrayAggFunc());} + } + {if (true) return (SqlCall) e;} + } else { + ; + } + if (orderList == null) { + {if (true) return SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause) + .createCall(span.end(this), valueExpr);} + } + {if (true) return SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause) + .createCall(span.end(this), valueExpr, orderList);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to TIMESTAMPADD. + */ + final public SqlCall TimestampAddFunctionCall() throws ParseException { + List args; + SqlNode e; + final Span s; + TimeUnit interval; + SqlNode node; + jj_consume_token(TIMESTAMPADD); + s = span(); + jj_consume_token(LPAREN); + interval = TimestampInterval(); + args = startList(SqlLiteral.createSymbol(interval, getPos())); + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.TIMESTAMP_ADD.createCall( + s.end(this), args);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to TIMESTAMPDIFF. + */ + final public SqlCall TimestampDiffFunctionCall() throws ParseException { + List args; + SqlNode e; + final Span s; + TimeUnit interval; + SqlNode node; + jj_consume_token(TIMESTAMPDIFF); + s = span(); + jj_consume_token(LPAREN); + interval = TimestampInterval(); + args = startList(SqlLiteral.createSymbol(interval, getPos())); + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(COMMA); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args.add(e); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.TIMESTAMP_DIFF.createCall( + s.end(this), args);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to a grouping function inside the GROUP BY clause, + * for example {@code TUMBLE(rowtime, INTERVAL '1' MINUTE)}. + */ + final public SqlCall GroupByWindowingCall() throws ParseException { + final Span s; + final List args; + final SqlOperator op; + if (jj_2_794(2)) { + jj_consume_token(TUMBLE); + op = SqlStdOperatorTable.TUMBLE_OLD; + } else if (jj_2_795(2)) { + jj_consume_token(HOP); + op = SqlStdOperatorTable.HOP_OLD; + } else if (jj_2_796(2)) { + jj_consume_token(SESSION); + op = SqlStdOperatorTable.SESSION_OLD; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + args = UnquantifiedFunctionParameterList(ExprContext.ACCEPT_SUB_QUERY); + {if (true) return op.createCall(s.end(this), args);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall MatchRecognizeFunctionCall() throws ParseException { + final SqlCall func; + final Span s; + if (jj_2_797(2)) { + jj_consume_token(CLASSIFIER); + s = span(); + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + func = SqlStdOperatorTable.CLASSIFIER.createCall(s.end(this)); + } else if (jj_2_798(2)) { + jj_consume_token(MATCH_NUMBER); + s = span(); + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + func = SqlStdOperatorTable.MATCH_NUMBER.createCall(s.end(this)); + } else if (jj_2_799(3)) { + func = MatchRecognizeNavigationLogical(); + } else if (jj_2_800(2)) { + func = MatchRecognizeNavigationPhysical(); + } else if (jj_2_801(2)) { + func = MatchRecognizeCallWithModifier(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return func;} + throw new Error("Missing return statement in function"); + } + + final public SqlCall MatchRecognizeCallWithModifier() throws ParseException { + final Span s; + final SqlOperator runningOp; + final SqlNode func; + if (jj_2_802(2)) { + jj_consume_token(RUNNING); + runningOp = SqlStdOperatorTable.RUNNING; + } else if (jj_2_803(2)) { + jj_consume_token(FINAL); + runningOp = SqlStdOperatorTable.FINAL; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + func = NamedFunctionCall(); + {if (true) return runningOp.createCall(s.end(func), func);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall MatchRecognizeNavigationLogical() throws ParseException { + final Span s = Span.of(); + SqlCall func; + final SqlOperator funcOp; + final SqlOperator runningOp; + SqlNode arg0; + SqlNode arg1 = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO); + if (jj_2_804(2)) { + jj_consume_token(RUNNING); + runningOp = SqlStdOperatorTable.RUNNING; s.add(this); + } else if (jj_2_805(2)) { + jj_consume_token(FINAL); + runningOp = SqlStdOperatorTable.FINAL; s.add(this); + } else { + runningOp = null; + } + if (jj_2_806(2)) { + jj_consume_token(FIRST); + funcOp = SqlStdOperatorTable.FIRST; + } else if (jj_2_807(2)) { + jj_consume_token(LAST); + funcOp = SqlStdOperatorTable.LAST; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s.add(this); + jj_consume_token(LPAREN); + arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY); + if (jj_2_808(2)) { + jj_consume_token(COMMA); + arg1 = NumericLiteral(); + } else { + ; + } + jj_consume_token(RPAREN); + func = funcOp.createCall(s.end(this), arg0, arg1); + if (runningOp != null) { + {if (true) return runningOp.createCall(s.end(this), func);} + } else { + {if (true) return func;} + } + throw new Error("Missing return statement in function"); + } + + final public SqlCall MatchRecognizeNavigationPhysical() throws ParseException { + final Span s; + SqlCall func; + SqlOperator funcOp; + SqlNode arg0; + SqlNode arg1 = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO); + if (jj_2_809(2)) { + jj_consume_token(PREV); + funcOp = SqlStdOperatorTable.PREV; + } else if (jj_2_810(2)) { + jj_consume_token(NEXT); + funcOp = SqlStdOperatorTable.NEXT; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + s = span(); + jj_consume_token(LPAREN); + arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY); + if (jj_2_811(2)) { + jj_consume_token(COMMA); + arg1 = NumericLiteral(); + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return funcOp.createCall(s.end(this), arg0, arg1);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall withinDistinct(SqlNode arg) throws ParseException { + final Span s; + final SqlNodeList distinctList; + jj_consume_token(WITHIN); + s = span(); + jj_consume_token(DISTINCT); + jj_consume_token(LPAREN); + distinctList = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.WITHIN_DISTINCT.createCall( + s.end(this), arg, distinctList);} + throw new Error("Missing return statement in function"); + } + + final public SqlCall withinGroup(SqlNode arg) throws ParseException { + final Span s; + final SqlNodeList orderList; + jj_consume_token(WITHIN); + s = span(); + jj_consume_token(GROUP); + jj_consume_token(LPAREN); + orderList = OrderBy(true); + jj_consume_token(RPAREN); + {if (true) return SqlStdOperatorTable.WITHIN_GROUP.createCall( + s.end(this), arg, orderList);} + throw new Error("Missing return statement in function"); + } + + final public Pair NullTreatment() throws ParseException { + final Span span; + if (jj_2_812(2)) { + jj_consume_token(IGNORE); + span = span(); + jj_consume_token(NULLS); + {if (true) return Pair.of(span.end(this), SqlStdOperatorTable.IGNORE_NULLS);} + } else if (jj_2_813(2)) { + jj_consume_token(RESPECT); + span = span(); + jj_consume_token(NULLS); + {if (true) return Pair.of(span.end(this), SqlStdOperatorTable.RESPECT_NULLS);} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public SqlCall nullTreatment(SqlCall arg) throws ParseException { + final Pair pair; + pair = NullTreatment(); + {if (true) return pair.right.createCall(pair.left, arg);} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a call to a named function (could be a builtin with regular + * syntax, or else a UDF). + * + *

NOTE: every UDF has two names: an invocation name and a + * specific name. Normally, function calls are resolved via overload + * resolution and invocation names. The SPECIFIC prefix allows overload + * resolution to be bypassed. Note that usage of the SPECIFIC prefix in + * queries is non-standard; it is used internally by Farrago, e.g. in stored + * view definitions to permanently bind references to a particular function + * after the overload resolution performed by view creation. + * + *

TODO jvs 25-Mar-2005: Once we have SQL-Flagger support, flag SPECIFIC + * as non-standard. + */ + final public SqlNode NamedFunctionCall() throws ParseException { + SqlCall call; + final Span filterSpan; + final SqlNode filter; + final Span overSpan; + final SqlNode over; + final Span withinGroupSpan; + if (jj_2_814(2)) { + call = StringAggFunctionCall(); + } else if (jj_2_815(2)) { + call = NamedCall(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_816(2)) { + call = nullTreatment(call); + } else { + ; + } + if (jj_2_817(2)) { + // decide between WITHIN DISTINCT and WITHIN GROUP + call = withinDistinct(call); + } else { + ; + } + if (jj_2_818(2)) { + call = withinGroup(call); + } else { + ; + } + if (jj_2_819(2)) { + jj_consume_token(FILTER); + filterSpan = span(); + jj_consume_token(LPAREN); + jj_consume_token(WHERE); + filter = Expression(ExprContext.ACCEPT_SUB_QUERY); + jj_consume_token(RPAREN); + call = SqlStdOperatorTable.FILTER.createCall( + filterSpan.end(this), call, filter); + } else { + ; + } + if (jj_2_822(2)) { + jj_consume_token(OVER); + overSpan = span(); + if (jj_2_820(2)) { + over = SimpleIdentifier(); + } else if (jj_2_821(2)) { + over = WindowSpecification(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + call = SqlStdOperatorTable.OVER.createCall(overSpan.end(over), call, over); + } else { + ; + } + {if (true) return call;} + throw new Error("Missing return statement in function"); + } + + final public SqlCall NamedCall() throws ParseException { + final SqlFunctionCategory funcType; + final SqlIdentifier qualifiedName; + final Span s; + final List args; + SqlLiteral quantifier = null; + if (jj_2_823(2)) { + jj_consume_token(SPECIFIC); + funcType = SqlFunctionCategory.USER_DEFINED_SPECIFIC_FUNCTION; + } else { + funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION; + } + qualifiedName = FunctionName(); + s = span(); + if (jj_2_824(2)) { + jj_consume_token(LPAREN); + jj_consume_token(STAR); + args = startList(SqlIdentifier.star(getPos())); + jj_consume_token(RPAREN); + } else if (jj_2_825(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + args = Collections.emptyList(); + } else if (jj_2_826(2)) { + args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY); + quantifier = (SqlLiteral) args.get(0); + args.remove(0); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return createCall(qualifiedName, s.end(this), funcType, quantifier, args);} + throw new Error("Missing return statement in function"); + } + +/* +* Parse Floor/Ceil function parameters +*/ + final public SqlNode StandardFloorCeilOptions(Span s, boolean floorFlag) throws ParseException { + SqlNode e; + final List args; + TimeUnit unit; + SqlCall function; + final Span s1; + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = startList(e); + if (jj_2_827(2)) { + jj_consume_token(TO); + unit = TimeUnit(); + args.add(new SqlIntervalQualifier(unit, null, getPos())); + } else { + ; + } + jj_consume_token(RPAREN); + SqlOperator op = floorFlag + ? SqlStdOperatorTable.FLOOR + : SqlStdOperatorTable.CEIL; + function = op.createCall(s.end(this), args); + if (jj_2_830(2)) { + jj_consume_token(OVER); + s1 = span(); + if (jj_2_828(2)) { + e = SimpleIdentifier(); + } else if (jj_2_829(2)) { + e = WindowSpecification(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return SqlStdOperatorTable.OVER.createCall(s1.end(this), function, e);} + } else { + {if (true) return function;} + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses the name of a JDBC function that is a token but is not reserved. + */ + final public String NonReservedJdbcFunctionName() throws ParseException { + jj_consume_token(SUBSTRING); + {if (true) return unquotedIdentifier();} + throw new Error("Missing return statement in function"); + } + +/** + * Parses the name of a function (either a compound identifier or + * a reserved word which can be used as a function name). + */ + final public SqlIdentifier FunctionName() throws ParseException { + SqlIdentifier qualifiedName; + if (jj_2_831(2)) { + qualifiedName = CompoundIdentifier(); + } else if (jj_2_832(2)) { + qualifiedName = ReservedFunctionName(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return qualifiedName;} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a reserved word which is used as the name of a function. + */ + final public SqlIdentifier ReservedFunctionName() throws ParseException { + if (jj_2_833(2)) { + jj_consume_token(ABS); + } else if (jj_2_834(2)) { + jj_consume_token(AVG); + } else if (jj_2_835(2)) { + jj_consume_token(CARDINALITY); + } else if (jj_2_836(2)) { + jj_consume_token(CEILING); + } else if (jj_2_837(2)) { + jj_consume_token(CHAR_LENGTH); + } else if (jj_2_838(2)) { + jj_consume_token(CHARACTER_LENGTH); + } else if (jj_2_839(2)) { + jj_consume_token(COALESCE); + } else if (jj_2_840(2)) { + jj_consume_token(COLLECT); + } else if (jj_2_841(2)) { + jj_consume_token(COVAR_POP); + } else if (jj_2_842(2)) { + jj_consume_token(COVAR_SAMP); + } else if (jj_2_843(2)) { + jj_consume_token(CUME_DIST); + } else if (jj_2_844(2)) { + jj_consume_token(COUNT); + } else if (jj_2_845(2)) { + jj_consume_token(CURRENT_DATE); + } else if (jj_2_846(2)) { + jj_consume_token(CURRENT_TIME); + } else if (jj_2_847(2)) { + jj_consume_token(CURRENT_TIMESTAMP); + } else if (jj_2_848(2)) { + jj_consume_token(DENSE_RANK); + } else if (jj_2_849(2)) { + jj_consume_token(ELEMENT); + } else if (jj_2_850(2)) { + jj_consume_token(EVERY); + } else if (jj_2_851(2)) { + jj_consume_token(EXP); + } else if (jj_2_852(2)) { + jj_consume_token(FIRST_VALUE); + } else if (jj_2_853(2)) { + jj_consume_token(FLOOR); + } else if (jj_2_854(2)) { + jj_consume_token(FUSION); + } else if (jj_2_855(2)) { + jj_consume_token(INTERSECTION); + } else if (jj_2_856(2)) { + jj_consume_token(GROUPING); + } else if (jj_2_857(2)) { + jj_consume_token(HOUR); + } else if (jj_2_858(2)) { + jj_consume_token(LAG); + } else if (jj_2_859(2)) { + jj_consume_token(LEAD); + } else if (jj_2_860(2)) { + jj_consume_token(LEFT); + } else if (jj_2_861(2)) { + jj_consume_token(LAST_VALUE); + } else if (jj_2_862(2)) { + jj_consume_token(LN); + } else if (jj_2_863(2)) { + jj_consume_token(LOCALTIME); + } else if (jj_2_864(2)) { + jj_consume_token(LOCALTIMESTAMP); + } else if (jj_2_865(2)) { + jj_consume_token(LOWER); + } else if (jj_2_866(2)) { + jj_consume_token(MAX); + } else if (jj_2_867(2)) { + jj_consume_token(MIN); + } else if (jj_2_868(2)) { + jj_consume_token(MINUTE); + } else if (jj_2_869(2)) { + jj_consume_token(MOD); + } else if (jj_2_870(2)) { + jj_consume_token(MONTH); + } else if (jj_2_871(2)) { + jj_consume_token(NTH_VALUE); + } else if (jj_2_872(2)) { + jj_consume_token(NTILE); + } else if (jj_2_873(2)) { + jj_consume_token(NULLIF); + } else if (jj_2_874(2)) { + jj_consume_token(OCTET_LENGTH); + } else if (jj_2_875(2)) { + jj_consume_token(PERCENT_RANK); + } else if (jj_2_876(2)) { + jj_consume_token(PERCENTILE_CONT); + } else if (jj_2_877(2)) { + jj_consume_token(PERCENTILE_DISC); + } else if (jj_2_878(2)) { + jj_consume_token(POWER); + } else if (jj_2_879(2)) { + jj_consume_token(RANK); + } else if (jj_2_880(2)) { + jj_consume_token(REGR_COUNT); + } else if (jj_2_881(2)) { + jj_consume_token(REGR_SXX); + } else if (jj_2_882(2)) { + jj_consume_token(REGR_SYY); + } else if (jj_2_883(2)) { + jj_consume_token(RIGHT); + } else if (jj_2_884(2)) { + jj_consume_token(ROW_NUMBER); + } else if (jj_2_885(2)) { + jj_consume_token(SECOND); + } else if (jj_2_886(2)) { + jj_consume_token(SOME); + } else if (jj_2_887(2)) { + jj_consume_token(SQRT); + } else if (jj_2_888(2)) { + jj_consume_token(STDDEV_POP); + } else if (jj_2_889(2)) { + jj_consume_token(STDDEV_SAMP); + } else if (jj_2_890(2)) { + jj_consume_token(SUM); + } else if (jj_2_891(2)) { + jj_consume_token(UPPER); + } else if (jj_2_892(2)) { + jj_consume_token(TRUNCATE); + } else if (jj_2_893(2)) { + jj_consume_token(USER); + } else if (jj_2_894(2)) { + jj_consume_token(VAR_POP); + } else if (jj_2_895(2)) { + jj_consume_token(VAR_SAMP); + } else if (jj_2_896(2)) { + jj_consume_token(YEAR); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlIdentifier(unquotedIdentifier(), getPos());} + throw new Error("Missing return statement in function"); + } + + final public SqlIdentifier ContextVariable() throws ParseException { + if (jj_2_897(2)) { + jj_consume_token(CURRENT_CATALOG); + } else if (jj_2_898(2)) { + jj_consume_token(CURRENT_DATE); + } else if (jj_2_899(2)) { + jj_consume_token(CURRENT_DEFAULT_TRANSFORM_GROUP); + } else if (jj_2_900(2)) { + jj_consume_token(CURRENT_PATH); + } else if (jj_2_901(2)) { + jj_consume_token(CURRENT_ROLE); + } else if (jj_2_902(2)) { + jj_consume_token(CURRENT_SCHEMA); + } else if (jj_2_903(2)) { + jj_consume_token(CURRENT_TIME); + } else if (jj_2_904(2)) { + jj_consume_token(CURRENT_TIMESTAMP); + } else if (jj_2_905(2)) { + jj_consume_token(CURRENT_USER); + } else if (jj_2_906(2)) { + jj_consume_token(LOCALTIME); + } else if (jj_2_907(2)) { + jj_consume_token(LOCALTIMESTAMP); + } else if (jj_2_908(2)) { + jj_consume_token(SESSION_USER); + } else if (jj_2_909(2)) { + jj_consume_token(SYSTEM_USER); + } else if (jj_2_910(2)) { + jj_consume_token(USER); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SqlIdentifier(unquotedIdentifier(), getPos());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a function call expression with JDBC syntax. + */ + final public SqlNode JdbcFunctionCall() throws ParseException { + String name; + SqlIdentifier id; + SqlNode e; + SqlLiteral tl; + SqlNodeList args; + SqlCall call; + final Span s, s1; + jj_consume_token(LBRACE_FN); + s = span(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TIMESTAMPADD: + call = TimestampAddFunctionCall(); + name = call.getOperator().getName(); + args = new SqlNodeList(call.getOperandList(), getPos()); + break; + default: + jj_la1[9] = jj_gen; + if (jj_2_921(3)) { + call = TimestampDiffFunctionCall(); + name = call.getOperator().getName(); + args = new SqlNodeList(call.getOperandList(), getPos()); + } else if (jj_2_922(2)) { + jj_consume_token(CONVERT); + name = unquotedIdentifier(); + jj_consume_token(LPAREN); + e = Expression(ExprContext.ACCEPT_SUB_QUERY); + args = new SqlNodeList(getPos()); + args.add(e); + jj_consume_token(COMMA); + tl = JdbcOdbcDataType(); + args.add(tl); + jj_consume_token(RPAREN); + } else if (jj_2_923(2)) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INSERT: + case LEFT: + case RIGHT: + case TRUNCATE: + if (jj_2_911(2)) { + jj_consume_token(INSERT); + } else if (jj_2_912(2)) { + jj_consume_token(LEFT); + } else if (jj_2_913(2)) { + jj_consume_token(RIGHT); + } else if (jj_2_914(2)) { + jj_consume_token(TRUNCATE); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + name = unquotedIdentifier(); + break; + default: + jj_la1[8] = jj_gen; + if (jj_2_915(2)) { + // For cases like {fn power(1,2)} and {fn lower('a')} + id = ReservedFunctionName(); + name = id.getSimple(); + } else if (jj_2_916(2)) { + // For cases like {fn substring('foo', 1,2)} + name = NonReservedJdbcFunctionName(); + } else if (jj_2_917(2)) { + name = Identifier(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + if (jj_2_918(2)) { + jj_consume_token(LPAREN); + jj_consume_token(STAR); + s1 = span(); + jj_consume_token(RPAREN); + args = new SqlNodeList(s1.pos()); + args.add(SqlIdentifier.star(s1.pos())); + } else if (jj_2_919(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + args = SqlNodeList.EMPTY; + } else if (jj_2_920(2)) { + args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(RBRACE); + {if (true) return new SqlJdbcFunctionCall(name).createCall(s.end(this), + args.getList());} + throw new Error("Missing return statement in function"); + } + +/** + * Parses a binary query operator like UNION. + */ + final public SqlBinaryOperator BinaryQueryOperator() throws ParseException { + if (jj_2_932(2)) { + jj_consume_token(UNION); + if (jj_2_924(2)) { + jj_consume_token(ALL); + {if (true) return SqlStdOperatorTable.UNION_ALL;} + } else if (jj_2_925(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.UNION;} + } else { + {if (true) return SqlStdOperatorTable.UNION;} + } + } else if (jj_2_933(2)) { + jj_consume_token(INTERSECT); + if (jj_2_926(2)) { + jj_consume_token(ALL); + {if (true) return SqlStdOperatorTable.INTERSECT_ALL;} + } else if (jj_2_927(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.INTERSECT;} + } else { + {if (true) return SqlStdOperatorTable.INTERSECT;} + } + } else if (jj_2_934(2)) { + if (jj_2_928(2)) { + jj_consume_token(EXCEPT); + } else if (jj_2_929(2)) { + jj_consume_token(SET_MINUS); + if (!this.conformance.isMinusAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.minusNotAllowed());} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (jj_2_930(2)) { + jj_consume_token(ALL); + {if (true) return SqlStdOperatorTable.EXCEPT_ALL;} + } else if (jj_2_931(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.EXCEPT;} + } else { + {if (true) return SqlStdOperatorTable.EXCEPT;} + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a binary multiset operator. + */ + final public SqlBinaryOperator BinaryMultisetOperator() throws ParseException { + jj_consume_token(MULTISET); + if (jj_2_944(2)) { + jj_consume_token(UNION); + if (jj_2_937(2)) { + if (jj_2_935(2)) { + jj_consume_token(ALL); + } else if (jj_2_936(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.MULTISET_UNION_DISTINCT;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return SqlStdOperatorTable.MULTISET_UNION;} + } else if (jj_2_945(2)) { + jj_consume_token(INTERSECT); + if (jj_2_940(2)) { + if (jj_2_938(2)) { + jj_consume_token(ALL); + } else if (jj_2_939(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.MULTISET_INTERSECT_DISTINCT;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return SqlStdOperatorTable.MULTISET_INTERSECT;} + } else if (jj_2_946(2)) { + jj_consume_token(EXCEPT); + if (jj_2_943(2)) { + if (jj_2_941(2)) { + jj_consume_token(ALL); + } else if (jj_2_942(2)) { + jj_consume_token(DISTINCT); + {if (true) return SqlStdOperatorTable.MULTISET_EXCEPT_DISTINCT;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + {if (true) return SqlStdOperatorTable.MULTISET_EXCEPT;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a binary row operator like AND. + */ + final public SqlBinaryOperator BinaryRowOperator() throws ParseException { + SqlBinaryOperator op; + if (jj_2_947(2)) { + jj_consume_token(EQ); + {if (true) return SqlStdOperatorTable.EQUALS;} + } else if (jj_2_948(2)) { + jj_consume_token(GT); + {if (true) return SqlStdOperatorTable.GREATER_THAN;} + } else if (jj_2_949(2)) { + jj_consume_token(LT); + {if (true) return SqlStdOperatorTable.LESS_THAN;} + } else if (jj_2_950(2)) { + jj_consume_token(LE); + {if (true) return SqlStdOperatorTable.LESS_THAN_OR_EQUAL;} + } else if (jj_2_951(2)) { + jj_consume_token(GE); + {if (true) return SqlStdOperatorTable.GREATER_THAN_OR_EQUAL;} + } else if (jj_2_952(2)) { + jj_consume_token(NE); + {if (true) return SqlStdOperatorTable.NOT_EQUALS;} + } else if (jj_2_953(2)) { + jj_consume_token(NE2); + if (!this.conformance.isBangEqualAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.bangEqualNotAllowed());} + } + {if (true) return SqlStdOperatorTable.NOT_EQUALS;} + } else if (jj_2_954(2)) { + jj_consume_token(PLUS); + {if (true) return SqlStdOperatorTable.PLUS;} + } else if (jj_2_955(2)) { + jj_consume_token(MINUS); + {if (true) return SqlStdOperatorTable.MINUS;} + } else if (jj_2_956(2)) { + jj_consume_token(STAR); + {if (true) return SqlStdOperatorTable.MULTIPLY;} + } else if (jj_2_957(2)) { + jj_consume_token(SLASH); + {if (true) return SqlStdOperatorTable.DIVIDE;} + } else if (jj_2_958(2)) { + jj_consume_token(PERCENT_REMAINDER); + if (!this.conformance.isPercentRemainderAllowed()) { + {if (true) throw SqlUtil.newContextException(getPos(), RESOURCE.percentRemainderNotAllowed());} + } + {if (true) return SqlStdOperatorTable.PERCENT_REMAINDER;} + } else if (jj_2_959(2)) { + jj_consume_token(CONCAT); + {if (true) return SqlStdOperatorTable.CONCAT;} + } else if (jj_2_960(2)) { + jj_consume_token(AND); + {if (true) return SqlStdOperatorTable.AND;} + } else if (jj_2_961(2)) { + jj_consume_token(OR); + {if (true) return SqlStdOperatorTable.OR;} + } else if (jj_2_962(2)) { + jj_consume_token(IS); + jj_consume_token(DISTINCT); + jj_consume_token(FROM); + {if (true) return SqlStdOperatorTable.IS_DISTINCT_FROM;} + } else if (jj_2_963(2)) { + jj_consume_token(IS); + jj_consume_token(NOT); + jj_consume_token(DISTINCT); + jj_consume_token(FROM); + {if (true) return SqlStdOperatorTable.IS_NOT_DISTINCT_FROM;} + } else if (jj_2_964(2)) { + jj_consume_token(MEMBER); + jj_consume_token(OF); + {if (true) return SqlStdOperatorTable.MEMBER_OF;} + } else if (jj_2_965(2)) { + jj_consume_token(SUBMULTISET); + jj_consume_token(OF); + {if (true) return SqlStdOperatorTable.SUBMULTISET_OF;} + } else if (jj_2_966(2)) { + jj_consume_token(NOT); + jj_consume_token(SUBMULTISET); + jj_consume_token(OF); + {if (true) return SqlStdOperatorTable.NOT_SUBMULTISET_OF;} + } else if (jj_2_967(2)) { + jj_consume_token(CONTAINS); + {if (true) return SqlStdOperatorTable.CONTAINS;} + } else if (jj_2_968(2)) { + jj_consume_token(OVERLAPS); + {if (true) return SqlStdOperatorTable.OVERLAPS;} + } else if (jj_2_969(2)) { + jj_consume_token(EQUALS); + {if (true) return SqlStdOperatorTable.PERIOD_EQUALS;} + } else if (jj_2_970(2)) { + jj_consume_token(PRECEDES); + {if (true) return SqlStdOperatorTable.PRECEDES;} + } else if (jj_2_971(2)) { + jj_consume_token(SUCCEEDS); + {if (true) return SqlStdOperatorTable.SUCCEEDS;} + } else if (jj_2_972(2)) { + jj_consume_token(IMMEDIATELY); + jj_consume_token(PRECEDES); + {if (true) return SqlStdOperatorTable.IMMEDIATELY_PRECEDES;} + } else if (jj_2_973(2)) { + jj_consume_token(IMMEDIATELY); + jj_consume_token(SUCCEEDS); + {if (true) return SqlStdOperatorTable.IMMEDIATELY_SUCCEEDS;} + } else if (jj_2_974(2)) { + op = BinaryMultisetOperator(); + {if (true) return op;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a prefix row operator like NOT. + */ + final public SqlPrefixOperator PrefixRowOperator() throws ParseException { + if (jj_2_975(2)) { + jj_consume_token(PLUS); + {if (true) return SqlStdOperatorTable.UNARY_PLUS;} + } else if (jj_2_976(2)) { + jj_consume_token(MINUS); + {if (true) return SqlStdOperatorTable.UNARY_MINUS;} + } else if (jj_2_977(2)) { + jj_consume_token(NOT); + {if (true) return SqlStdOperatorTable.NOT;} + } else if (jj_2_978(2)) { + jj_consume_token(EXISTS); + {if (true) return SqlStdOperatorTable.EXISTS;} + } else if (jj_2_979(2)) { + jj_consume_token(UNIQUE); + {if (true) return SqlStdOperatorTable.UNIQUE;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a postfix row operator like IS NOT NULL. + */ + final public SqlPostfixOperator PostfixRowOperator() throws ParseException { + if (jj_2_1004(2)) { + jj_consume_token(IS); + if (jj_2_1001(2)) { + jj_consume_token(A); + jj_consume_token(SET); + {if (true) return SqlStdOperatorTable.IS_A_SET;} + } else if (jj_2_1002(2)) { + jj_consume_token(NOT); + if (jj_2_980(2)) { + jj_consume_token(NULL); + {if (true) return SqlStdOperatorTable.IS_NOT_NULL;} + } else if (jj_2_981(2)) { + jj_consume_token(TRUE); + {if (true) return SqlStdOperatorTable.IS_NOT_TRUE;} + } else if (jj_2_982(2)) { + jj_consume_token(FALSE); + {if (true) return SqlStdOperatorTable.IS_NOT_FALSE;} + } else if (jj_2_983(2)) { + jj_consume_token(UNKNOWN); + {if (true) return SqlStdOperatorTable.IS_NOT_UNKNOWN;} + } else if (jj_2_984(2)) { + jj_consume_token(A); + jj_consume_token(SET); + {if (true) return SqlStdOperatorTable.IS_NOT_A_SET;} + } else if (jj_2_985(2)) { + jj_consume_token(EMPTY); + {if (true) return SqlStdOperatorTable.IS_NOT_EMPTY;} + } else if (jj_2_986(2)) { + jj_consume_token(JSON); + jj_consume_token(VALUE); + {if (true) return SqlStdOperatorTable.IS_NOT_JSON_VALUE;} + } else if (jj_2_987(2)) { + jj_consume_token(JSON); + jj_consume_token(OBJECT); + {if (true) return SqlStdOperatorTable.IS_NOT_JSON_OBJECT;} + } else if (jj_2_988(2)) { + jj_consume_token(JSON); + jj_consume_token(ARRAY); + {if (true) return SqlStdOperatorTable.IS_NOT_JSON_ARRAY;} + } else if (jj_2_989(2)) { + jj_consume_token(JSON); + jj_consume_token(SCALAR); + {if (true) return SqlStdOperatorTable.IS_NOT_JSON_SCALAR;} + } else if (jj_2_990(2)) { + jj_consume_token(JSON); + {if (true) return SqlStdOperatorTable.IS_NOT_JSON_VALUE;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_1003(2)) { + if (jj_2_991(2)) { + jj_consume_token(NULL); + {if (true) return SqlStdOperatorTable.IS_NULL;} + } else if (jj_2_992(2)) { + jj_consume_token(TRUE); + {if (true) return SqlStdOperatorTable.IS_TRUE;} + } else if (jj_2_993(2)) { + jj_consume_token(FALSE); + {if (true) return SqlStdOperatorTable.IS_FALSE;} + } else if (jj_2_994(2)) { + jj_consume_token(UNKNOWN); + {if (true) return SqlStdOperatorTable.IS_UNKNOWN;} + } else if (jj_2_995(2)) { + jj_consume_token(EMPTY); + {if (true) return SqlStdOperatorTable.IS_EMPTY;} + } else if (jj_2_996(2)) { + jj_consume_token(JSON); + jj_consume_token(VALUE); + {if (true) return SqlStdOperatorTable.IS_JSON_VALUE;} + } else if (jj_2_997(2)) { + jj_consume_token(JSON); + jj_consume_token(OBJECT); + {if (true) return SqlStdOperatorTable.IS_JSON_OBJECT;} + } else if (jj_2_998(2)) { + jj_consume_token(JSON); + jj_consume_token(ARRAY); + {if (true) return SqlStdOperatorTable.IS_JSON_ARRAY;} + } else if (jj_2_999(2)) { + jj_consume_token(JSON); + jj_consume_token(SCALAR); + {if (true) return SqlStdOperatorTable.IS_JSON_SCALAR;} + } else if (jj_2_1000(2)) { + jj_consume_token(JSON); + {if (true) return SqlStdOperatorTable.IS_JSON_VALUE;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else if (jj_2_1005(2)) { + jj_consume_token(FORMAT); + JsonRepresentation(); + {if (true) return SqlStdOperatorTable.JSON_VALUE_EXPRESSION;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/** + * Parses a non-reserved keyword for use as an identifier. + * + *

The method is broken up into several sub-methods; without this + * decomposition, parsers such as Babel with more than ~1,000 non-reserved + * keywords would generate such deeply nested 'if' statements that javac would + * fail with a {@link StackOverflowError}. + * + *

The list is generated from the FMPP config data. To add or remove + * keywords, modify config.fmpp. For parsers except Babel, make sure that + * keywords are not reserved by the SQL standard. + * + * @see Glossary#SQL2003 SQL:2003 Part 2 Section 5.2 + */ + final public String NonReservedKeyWord() throws ParseException { + if (jj_2_1006(2)) { + NonReservedKeyWord0of3(); + } else if (jj_2_1007(2)) { + NonReservedKeyWord1of3(); + } else if (jj_2_1008(2)) { + NonReservedKeyWord2of3(); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return unquotedIdentifier();} + throw new Error("Missing return statement in function"); + } + +/** @see #NonReservedKeyWord */ + final public void NonReservedKeyWord0of3() throws ParseException { + if (jj_2_1009(2)) { + jj_consume_token(SEMI); + } else if (jj_2_1010(2)) { + jj_consume_token(AFFINITY_KEY); + } else if (jj_2_1011(2)) { + jj_consume_token(CACHE_GROUP); + } else if (jj_2_1012(2)) { + jj_consume_token(VALUE_TYPE); + } else if (jj_2_1013(2)) { + jj_consume_token(INLINE_SIZE); + } else if (jj_2_1014(2)) { + jj_consume_token(PASSWORD); + } else if (jj_2_1015(2)) { + jj_consume_token(CONTINUOUS); + } else if (jj_2_1016(2)) { + jj_consume_token(ASYNC); + } else if (jj_2_1017(2)) { + jj_consume_token(A); + } else if (jj_2_1018(2)) { + jj_consume_token(ACTION); + } else if (jj_2_1019(2)) { + jj_consume_token(ALLOCATE); + } else if (jj_2_1020(2)) { + jj_consume_token(AND); + } else if (jj_2_1021(2)) { + jj_consume_token(ARRAY_MAX_CARDINALITY); + } else if (jj_2_1022(2)) { + jj_consume_token(ASENSITIVE); + } else if (jj_2_1023(2)) { + jj_consume_token(AT); + } else if (jj_2_1024(2)) { + jj_consume_token(AVG); + } else if (jj_2_1025(2)) { + jj_consume_token(BEGIN_FRAME); + } else if (jj_2_1026(2)) { + jj_consume_token(BIGINT); + } else if (jj_2_1027(2)) { + jj_consume_token(BLOB); + } else if (jj_2_1028(2)) { + jj_consume_token(BREADTH); + } else if (jj_2_1029(2)) { + jj_consume_token(CALLED); + } else if (jj_2_1030(2)) { + jj_consume_token(CASCADED); + } else if (jj_2_1031(2)) { + jj_consume_token(CEIL); + } else if (jj_2_1032(2)) { + jj_consume_token(CHARACTER); + } else if (jj_2_1033(2)) { + jj_consume_token(CHECK); + } else if (jj_2_1034(2)) { + jj_consume_token(CLOSE); + } else if (jj_2_1035(2)) { + jj_consume_token(COLLATION); + } else if (jj_2_1036(2)) { + jj_consume_token(COMMIT); + } else if (jj_2_1037(2)) { + jj_consume_token(CONNECTION); + } else if (jj_2_1038(2)) { + jj_consume_token(CONTAINS); + } else if (jj_2_1039(2)) { + jj_consume_token(CORR); + } else if (jj_2_1040(2)) { + jj_consume_token(COVAR_POP); + } else if (jj_2_1041(2)) { + jj_consume_token(CUME_DIST); + } else if (jj_2_1042(2)) { + jj_consume_token(CURRENT_DEFAULT_TRANSFORM_GROUP); + } else if (jj_2_1043(2)) { + jj_consume_token(CURRENT_ROW); + } else if (jj_2_1044(2)) { + jj_consume_token(CURRENT_TIMESTAMP); + } else if (jj_2_1045(2)) { + jj_consume_token(CYCLE); + } else if (jj_2_1046(2)) { + jj_consume_token(DAY); + } else if (jj_2_1047(2)) { + jj_consume_token(DECIMAL); + } else if (jj_2_1048(2)) { + jj_consume_token(DEFERRED); + } else if (jj_2_1049(2)) { + jj_consume_token(DEREF); + } else if (jj_2_1050(2)) { + jj_consume_token(DETERMINISTIC); + } else if (jj_2_1051(2)) { + jj_consume_token(DISCONNECT); + } else if (jj_2_1052(2)) { + jj_consume_token(DYNAMIC); + } else if (jj_2_1053(2)) { + jj_consume_token(ELSE); + } else if (jj_2_1054(2)) { + jj_consume_token(END_FRAME); + } else if (jj_2_1055(2)) { + jj_consume_token(ESCAPE); + } else if (jj_2_1056(2)) { + jj_consume_token(EXEC); + } else if (jj_2_1057(2)) { + jj_consume_token(EXP); + } else if (jj_2_1058(2)) { + jj_consume_token(EXTRACT); + } else if (jj_2_1059(2)) { + jj_consume_token(FIRST); + } else if (jj_2_1060(2)) { + jj_consume_token(FLOOR); + } else if (jj_2_1061(2)) { + jj_consume_token(FOUND); + } else if (jj_2_1062(2)) { + jj_consume_token(FUNCTION); + } else if (jj_2_1063(2)) { + jj_consume_token(GENERAL); + } else if (jj_2_1064(2)) { + jj_consume_token(GO); + } else if (jj_2_1065(2)) { + jj_consume_token(HOLD); + } else if (jj_2_1066(2)) { + jj_consume_token(IMMEDIATE); + } else if (jj_2_1067(2)) { + jj_consume_token(INDICATOR); + } else if (jj_2_1068(2)) { + jj_consume_token(INOUT); + } else if (jj_2_1069(2)) { + jj_consume_token(INT); + } else if (jj_2_1070(2)) { + jj_consume_token(IS); + } else if (jj_2_1071(2)) { + jj_consume_token(JSON_ARRAYAGG); + } else if (jj_2_1072(2)) { + jj_consume_token(JSON_OBJECTAGG); + } else if (jj_2_1073(2)) { + jj_consume_token(K); + } else if (jj_2_1074(2)) { + jj_consume_token(LANGUAGE); + } else if (jj_2_1075(2)) { + jj_consume_token(LAST_VALUE); + } else if (jj_2_1076(2)) { + jj_consume_token(LENGTH); + } else if (jj_2_1077(2)) { + jj_consume_token(LIKE_REGEX); + } else if (jj_2_1078(2)) { + jj_consume_token(LOCALTIME); + } else if (jj_2_1079(2)) { + jj_consume_token(LOWER); + } else if (jj_2_1080(2)) { + jj_consume_token(MATCH); + } else if (jj_2_1081(2)) { + jj_consume_token(MAX); + } else if (jj_2_1082(2)) { + jj_consume_token(METHOD); + } else if (jj_2_1083(2)) { + jj_consume_token(MOD); + } else if (jj_2_1084(2)) { + jj_consume_token(MONTH); + } else if (jj_2_1085(2)) { + jj_consume_token(NAMES); + } else if (jj_2_1086(2)) { + jj_consume_token(NCLOB); + } else if (jj_2_1087(2)) { + jj_consume_token(NORMALIZE); + } else if (jj_2_1088(2)) { + jj_consume_token(NTILE); + } else if (jj_2_1089(2)) { + jj_consume_token(OBJECT); + } else if (jj_2_1090(2)) { + jj_consume_token(OF); + } else if (jj_2_1091(2)) { + jj_consume_token(ONE); + } else if (jj_2_1092(2)) { + jj_consume_token(OPTION); + } else if (jj_2_1093(2)) { + jj_consume_token(OUT); + } else if (jj_2_1094(2)) { + jj_consume_token(OVERLAY); + } else if (jj_2_1095(2)) { + jj_consume_token(PARTIAL); + } else if (jj_2_1096(2)) { + jj_consume_token(PERCENT); + } else if (jj_2_1097(2)) { + jj_consume_token(PERCENT_RANK); + } else if (jj_2_1098(2)) { + jj_consume_token(PORTION); + } else if (jj_2_1099(2)) { + jj_consume_token(POWER); + } else if (jj_2_1100(2)) { + jj_consume_token(PREPARE); + } else if (jj_2_1101(2)) { + jj_consume_token(PRIOR); + } else if (jj_2_1102(2)) { + jj_consume_token(PUBLIC); + } else if (jj_2_1103(2)) { + jj_consume_token(READ); + } else if (jj_2_1104(2)) { + jj_consume_token(RECURSIVE); + } else if (jj_2_1105(2)) { + jj_consume_token(REFERENCING); + } else if (jj_2_1106(2)) { + jj_consume_token(REGR_COUNT); + } else if (jj_2_1107(2)) { + jj_consume_token(REGR_SLOPE); + } else if (jj_2_1108(2)) { + jj_consume_token(REGR_SYY); + } else if (jj_2_1109(2)) { + jj_consume_token(REPLACE); + } else if (jj_2_1110(2)) { + jj_consume_token(RESULT); + } else if (jj_2_1111(2)) { + jj_consume_token(REVOKE); + } else if (jj_2_1112(2)) { + jj_consume_token(ROUTINE); + } else if (jj_2_1113(2)) { + jj_consume_token(SAVEPOINT); + } else if (jj_2_1114(2)) { + jj_consume_token(SCROLL); + } else if (jj_2_1115(2)) { + jj_consume_token(SECTION); + } else if (jj_2_1116(2)) { + jj_consume_token(SESSION); + } else if (jj_2_1117(2)) { + jj_consume_token(SIMILAR); + } else if (jj_2_1118(2)) { + jj_consume_token(SPACE); + } else if (jj_2_1119(2)) { + jj_consume_token(SQL); + } else if (jj_2_1120(2)) { + jj_consume_token(SQLWARNING); + } else if (jj_2_1121(2)) { + jj_consume_token(STATE); + } else if (jj_2_1122(2)) { + jj_consume_token(STDDEV_SAMP); + } else if (jj_2_1123(2)) { + jj_consume_token(SUBSTRING); + } else if (jj_2_1124(2)) { + jj_consume_token(SUM); + } else if (jj_2_1125(2)) { + jj_consume_token(SYSTEM_TIME); + } else if (jj_2_1126(2)) { + jj_consume_token(TIMEZONE_HOUR); + } else if (jj_2_1127(2)) { + jj_consume_token(TO); + } else if (jj_2_1128(2)) { + jj_consume_token(TRANSLATE); + } else if (jj_2_1129(2)) { + jj_consume_token(TREAT); + } else if (jj_2_1130(2)) { + jj_consume_token(TRIM_ARRAY); + } else if (jj_2_1131(2)) { + jj_consume_token(UESCAPE); + } else if (jj_2_1132(2)) { + jj_consume_token(UNKNOWN); + } else if (jj_2_1133(2)) { + jj_consume_token(USAGE); + } else if (jj_2_1134(2)) { + jj_consume_token(VALUE_OF); + } else if (jj_2_1135(2)) { + jj_consume_token(VARYING); + } else if (jj_2_1136(2)) { + jj_consume_token(VERSION); + } else if (jj_2_1137(2)) { + jj_consume_token(WEEK); + } else if (jj_2_1138(2)) { + jj_consume_token(WITHIN); + } else if (jj_2_1139(2)) { + jj_consume_token(WRITE); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + +/** @see #NonReservedKeyWord */ + final public void NonReservedKeyWord1of3() throws ParseException { + if (jj_2_1140(2)) { + jj_consume_token(TEMPLATE); + } else if (jj_2_1141(2)) { + jj_consume_token(ATOMICITY); + } else if (jj_2_1142(2)) { + jj_consume_token(CACHE_NAME); + } else if (jj_2_1143(2)) { + jj_consume_token(ENCRYPTED); + } else if (jj_2_1144(2)) { + jj_consume_token(LOGGING); + } else if (jj_2_1145(2)) { + jj_consume_token(KILL); + } else if (jj_2_1146(2)) { + jj_consume_token(SERVICE); + } else if (jj_2_1147(2)) { + jj_consume_token(QUERY); + } else if (jj_2_1148(2)) { + jj_consume_token(ABS); + } else if (jj_2_1149(2)) { + jj_consume_token(ADD); + } else if (jj_2_1150(2)) { + jj_consume_token(ALLOW); + } else if (jj_2_1151(2)) { + jj_consume_token(ARE); + } else if (jj_2_1152(2)) { + jj_consume_token(AS); + } else if (jj_2_1153(2)) { + jj_consume_token(ASSERTION); + } else if (jj_2_1154(2)) { + jj_consume_token(ATOMIC); + } else if (jj_2_1155(2)) { + jj_consume_token(BEFORE); + } else if (jj_2_1156(2)) { + jj_consume_token(BEGIN_PARTITION); + } else if (jj_2_1157(2)) { + jj_consume_token(BINARY); + } else if (jj_2_1158(2)) { + jj_consume_token(BOOLEAN); + } else if (jj_2_1159(2)) { + jj_consume_token(BY); + } else if (jj_2_1160(2)) { + jj_consume_token(CARDINALITY); + } else if (jj_2_1161(2)) { + jj_consume_token(CAST); + } else if (jj_2_1162(2)) { + jj_consume_token(CEILING); + } else if (jj_2_1163(2)) { + jj_consume_token(CHARACTER_LENGTH); + } else if (jj_2_1164(2)) { + jj_consume_token(CLASSIFIER); + } else if (jj_2_1165(2)) { + jj_consume_token(COALESCE); + } else if (jj_2_1166(2)) { + jj_consume_token(COLLECT); + } else if (jj_2_1167(2)) { + jj_consume_token(CONDITION); + } else if (jj_2_1168(2)) { + jj_consume_token(CONSTRAINTS); + } else if (jj_2_1169(2)) { + jj_consume_token(CONTINUE); + } else if (jj_2_1170(2)) { + jj_consume_token(CORRESPONDING); + } else if (jj_2_1171(2)) { + jj_consume_token(COVAR_SAMP); + } else if (jj_2_1172(2)) { + jj_consume_token(CURRENT_CATALOG); + } else if (jj_2_1173(2)) { + jj_consume_token(CURRENT_PATH); + } else if (jj_2_1174(2)) { + jj_consume_token(CURRENT_SCHEMA); + } else if (jj_2_1175(2)) { + jj_consume_token(CURRENT_TRANSFORM_GROUP_FOR_TYPE); + } else if (jj_2_1176(2)) { + jj_consume_token(DATA); + } else if (jj_2_1177(2)) { + jj_consume_token(DEALLOCATE); + } else if (jj_2_1178(2)) { + jj_consume_token(DECLARE); + } else if (jj_2_1179(2)) { + jj_consume_token(DENSE_RANK); + } else if (jj_2_1180(2)) { + jj_consume_token(DESC); + } else if (jj_2_1181(2)) { + jj_consume_token(DIAGNOSTICS); + } else if (jj_2_1182(2)) { + jj_consume_token(DOMAIN); + } else if (jj_2_1183(2)) { + jj_consume_token(EACH); + } else if (jj_2_1184(2)) { + jj_consume_token(EMPTY); + } else if (jj_2_1185(2)) { + jj_consume_token(END_PARTITION); + } else if (jj_2_1186(2)) { + jj_consume_token(EVERY); + } else if (jj_2_1187(2)) { + jj_consume_token(EXECUTE); + } else if (jj_2_1188(2)) { + jj_consume_token(EXTEND); + } else if (jj_2_1189(2)) { + jj_consume_token(FALSE); + } else if (jj_2_1190(2)) { + jj_consume_token(FIRST_VALUE); + } else if (jj_2_1191(2)) { + jj_consume_token(FOR); + } else if (jj_2_1192(2)) { + jj_consume_token(FRAME_ROW); + } else if (jj_2_1193(2)) { + jj_consume_token(FUSION); + } else if (jj_2_1194(2)) { + jj_consume_token(GET); + } else if (jj_2_1195(2)) { + jj_consume_token(GOTO); + } else if (jj_2_1196(2)) { + jj_consume_token(HOUR); + } else if (jj_2_1197(2)) { + jj_consume_token(IMMEDIATELY); + } else if (jj_2_1198(2)) { + jj_consume_token(INITIAL); + } else if (jj_2_1199(2)) { + jj_consume_token(INPUT); + } else if (jj_2_1200(2)) { + jj_consume_token(INTEGER); + } else if (jj_2_1201(2)) { + jj_consume_token(ISOLATION); + } else if (jj_2_1202(2)) { + jj_consume_token(JSON_EXISTS); + } else if (jj_2_1203(2)) { + jj_consume_token(JSON_QUERY); + } else if (jj_2_1204(2)) { + jj_consume_token(KEY); + } else if (jj_2_1205(2)) { + jj_consume_token(LARGE); + } else if (jj_2_1206(2)) { + jj_consume_token(LEAD); + } else if (jj_2_1207(2)) { + jj_consume_token(LEVEL); + } else if (jj_2_1208(2)) { + jj_consume_token(LN); + } else if (jj_2_1209(2)) { + jj_consume_token(LOCALTIMESTAMP); + } else if (jj_2_1210(2)) { + jj_consume_token(M); + } else if (jj_2_1211(2)) { + jj_consume_token(MATCHES); + } else if (jj_2_1212(2)) { + jj_consume_token(MEASURES); + } else if (jj_2_1213(2)) { + jj_consume_token(MIN); + } else if (jj_2_1214(2)) { + jj_consume_token(MODIFIES); + } else if (jj_2_1215(2)) { + jj_consume_token(MULTISET); + } else if (jj_2_1216(2)) { + jj_consume_token(NATIONAL); + } else if (jj_2_1217(2)) { + jj_consume_token(NO); + } else if (jj_2_1218(2)) { + jj_consume_token(NOT); + } else if (jj_2_1219(2)) { + jj_consume_token(NULLIF); + } else if (jj_2_1220(2)) { + jj_consume_token(OCCURRENCES_REGEX); + } else if (jj_2_1221(2)) { + jj_consume_token(OLD); + } else if (jj_2_1222(2)) { + jj_consume_token(ONLY); + } else if (jj_2_1223(2)) { + jj_consume_token(OR); + } else if (jj_2_1224(2)) { + jj_consume_token(OUTPUT); + } else if (jj_2_1225(2)) { + jj_consume_token(PAD); + } else if (jj_2_1226(2)) { + jj_consume_token(PATH); + } else if (jj_2_1227(2)) { + jj_consume_token(PERCENTILE_CONT); + } else if (jj_2_1228(2)) { + jj_consume_token(PERIOD); + } else if (jj_2_1229(2)) { + jj_consume_token(POSITION); + } else if (jj_2_1230(2)) { + jj_consume_token(PRECEDES); + } else if (jj_2_1231(2)) { + jj_consume_token(PRESERVE); + } else if (jj_2_1232(2)) { + jj_consume_token(PRIVILEGES); + } else if (jj_2_1233(2)) { + jj_consume_token(QUARTER); + } else if (jj_2_1234(2)) { + jj_consume_token(READS); + } else if (jj_2_1235(2)) { + jj_consume_token(REF); + } else if (jj_2_1236(2)) { + jj_consume_token(REGR_AVGX); + } else if (jj_2_1237(2)) { + jj_consume_token(REGR_INTERCEPT); + } else if (jj_2_1238(2)) { + jj_consume_token(REGR_SXX); + } else if (jj_2_1239(2)) { + jj_consume_token(RELATIVE); + } else if (jj_2_1240(2)) { + jj_consume_token(RESET); + } else if (jj_2_1241(2)) { + jj_consume_token(RETURN); + } else if (jj_2_1242(2)) { + jj_consume_token(ROLE); + } else if (jj_2_1243(2)) { + jj_consume_token(ROW_NUMBER); + } else if (jj_2_1244(2)) { + jj_consume_token(SCHEMA); + } else if (jj_2_1245(2)) { + jj_consume_token(SEARCH); + } else if (jj_2_1246(2)) { + jj_consume_token(SEEK); + } else if (jj_2_1247(2)) { + jj_consume_token(SESSION_USER); + } else if (jj_2_1248(2)) { + jj_consume_token(SIZE); + } else if (jj_2_1249(2)) { + jj_consume_token(SPECIFIC); + } else if (jj_2_1250(2)) { + jj_consume_token(SQLEXCEPTION); + } else if (jj_2_1251(2)) { + jj_consume_token(SQRT); + } else if (jj_2_1252(2)) { + jj_consume_token(STATIC); + } else if (jj_2_1253(2)) { + jj_consume_token(SUBMULTISET); + } else if (jj_2_1254(2)) { + jj_consume_token(SUBSTRING_REGEX); + } else if (jj_2_1255(2)) { + jj_consume_token(SYMMETRIC); + } else if (jj_2_1256(2)) { + jj_consume_token(SYSTEM_USER); + } else if (jj_2_1257(2)) { + jj_consume_token(TIMEZONE_MINUTE); + } else if (jj_2_1258(2)) { + jj_consume_token(TRAILING); + } else if (jj_2_1259(2)) { + jj_consume_token(TRANSLATE_REGEX); + } else if (jj_2_1260(2)) { + jj_consume_token(TRIGGER); + } else if (jj_2_1261(2)) { + jj_consume_token(TRUE); + } else if (jj_2_1262(2)) { + jj_consume_token(UNDER); + } else if (jj_2_1263(2)) { + jj_consume_token(UPPER); + } else if (jj_2_1264(2)) { + jj_consume_token(USER); + } else if (jj_2_1265(2)) { + jj_consume_token(VARBINARY); + } else if (jj_2_1266(2)) { + jj_consume_token(VAR_POP); + } else if (jj_2_1267(2)) { + jj_consume_token(VERSIONING); + } else if (jj_2_1268(2)) { + jj_consume_token(WHENEVER); + } else if (jj_2_1269(2)) { + jj_consume_token(WITHOUT); + } else if (jj_2_1270(2)) { + jj_consume_token(YEAR); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + +/** @see #NonReservedKeyWord */ + final public void NonReservedKeyWord2of3() throws ParseException { + if (jj_2_1271(2)) { + jj_consume_token(BACKUPS); + } else if (jj_2_1272(2)) { + jj_consume_token(WRITE_SYNCHRONIZATION_MODE); + } else if (jj_2_1273(2)) { + jj_consume_token(DATA_REGION); + } else if (jj_2_1274(2)) { + jj_consume_token(PARALLEL); + } else if (jj_2_1275(2)) { + jj_consume_token(NOLOGGING); + } else if (jj_2_1276(2)) { + jj_consume_token(SCAN); + } else if (jj_2_1277(2)) { + jj_consume_token(COMPUTE); + } else if (jj_2_1278(2)) { + jj_consume_token(UUID); + } else if (jj_2_1279(2)) { + jj_consume_token(ABSOLUTE); + } else if (jj_2_1280(2)) { + jj_consume_token(AFTER); + } else if (jj_2_1281(2)) { + jj_consume_token(ALTER); + } else if (jj_2_1282(2)) { + jj_consume_token(ARRAY); + } else if (jj_2_1283(2)) { + jj_consume_token(ASC); + } else if (jj_2_1284(2)) { + jj_consume_token(ASYMMETRIC); + } else if (jj_2_1285(2)) { + jj_consume_token(AUTHORIZATION); + } else if (jj_2_1286(2)) { + jj_consume_token(BEGIN); + } else if (jj_2_1287(2)) { + jj_consume_token(BETWEEN); + } else if (jj_2_1288(2)) { + jj_consume_token(BIT); + } else if (jj_2_1289(2)) { + jj_consume_token(BOTH); + } else if (jj_2_1290(2)) { + jj_consume_token(C); + } else if (jj_2_1291(2)) { + jj_consume_token(CASCADE); + } else if (jj_2_1292(2)) { + jj_consume_token(CATALOG); + } else if (jj_2_1293(2)) { + jj_consume_token(CHAR); + } else if (jj_2_1294(2)) { + jj_consume_token(CHAR_LENGTH); + } else if (jj_2_1295(2)) { + jj_consume_token(CLOB); + } else if (jj_2_1296(2)) { + jj_consume_token(COLLATE); + } else if (jj_2_1297(2)) { + jj_consume_token(COLUMN); + } else if (jj_2_1298(2)) { + jj_consume_token(CONNECT); + } else if (jj_2_1299(2)) { + jj_consume_token(CONSTRUCTOR); + } else if (jj_2_1300(2)) { + jj_consume_token(CONVERT); + } else if (jj_2_1301(2)) { + jj_consume_token(COUNT); + } else if (jj_2_1302(2)) { + jj_consume_token(CUBE); + } else if (jj_2_1303(2)) { + jj_consume_token(CURRENT_DATE); + } else if (jj_2_1304(2)) { + jj_consume_token(CURRENT_ROLE); + } else if (jj_2_1305(2)) { + jj_consume_token(CURRENT_TIME); + } else if (jj_2_1306(2)) { + jj_consume_token(CURRENT_USER); + } else if (jj_2_1307(2)) { + jj_consume_token(DATE); + } else if (jj_2_1308(2)) { + jj_consume_token(DEC); + } else if (jj_2_1309(2)) { + jj_consume_token(DEFERRABLE); + } else if (jj_2_1310(2)) { + jj_consume_token(DEPTH); + } else if (jj_2_1311(2)) { + jj_consume_token(DESCRIPTOR); + } else if (jj_2_1312(2)) { + jj_consume_token(DISALLOW); + } else if (jj_2_1313(2)) { + jj_consume_token(DOUBLE); + } else if (jj_2_1314(2)) { + jj_consume_token(ELEMENT); + } else if (jj_2_1315(2)) { + jj_consume_token(END); + } else if (jj_2_1316(2)) { + jj_consume_token(EQUALS); + } else if (jj_2_1317(2)) { + jj_consume_token(EXCEPTION); + } else if (jj_2_1318(2)) { + jj_consume_token(EXISTS); + } else if (jj_2_1319(2)) { + jj_consume_token(EXTERNAL); + } else if (jj_2_1320(2)) { + jj_consume_token(FILTER); + } else if (jj_2_1321(2)) { + jj_consume_token(FLOAT); + } else if (jj_2_1322(2)) { + jj_consume_token(FOREIGN); + } else if (jj_2_1323(2)) { + jj_consume_token(FREE); + } else if (jj_2_1324(2)) { + jj_consume_token(G); + } else if (jj_2_1325(2)) { + jj_consume_token(GLOBAL); + } else if (jj_2_1326(2)) { + jj_consume_token(GROUPS); + } else if (jj_2_1327(2)) { + jj_consume_token(IDENTITY); + } else if (jj_2_1328(2)) { + jj_consume_token(IMPORT); + } else if (jj_2_1329(2)) { + jj_consume_token(INITIALLY); + } else if (jj_2_1330(2)) { + jj_consume_token(INSENSITIVE); + } else if (jj_2_1331(2)) { + jj_consume_token(INTERSECTION); + } else if (jj_2_1332(2)) { + jj_consume_token(JSON_ARRAY); + } else if (jj_2_1333(2)) { + jj_consume_token(JSON_OBJECT); + } else if (jj_2_1334(2)) { + jj_consume_token(JSON_VALUE); + } else if (jj_2_1335(2)) { + jj_consume_token(LAG); + } else if (jj_2_1336(2)) { + jj_consume_token(LAST); + } else if (jj_2_1337(2)) { + jj_consume_token(LEADING); + } else if (jj_2_1338(2)) { + jj_consume_token(LIKE); + } else if (jj_2_1339(2)) { + jj_consume_token(LOCAL); + } else if (jj_2_1340(2)) { + jj_consume_token(LOCATOR); + } else if (jj_2_1341(2)) { + jj_consume_token(MAP); + } else if (jj_2_1342(2)) { + jj_consume_token(MATCH_NUMBER); + } else if (jj_2_1343(2)) { + jj_consume_token(MEMBER); + } else if (jj_2_1344(2)) { + jj_consume_token(MINUTE); + } else if (jj_2_1345(2)) { + jj_consume_token(MODULE); + } else if (jj_2_1346(2)) { + jj_consume_token(NAME); + } else if (jj_2_1347(2)) { + jj_consume_token(NCHAR); + } else if (jj_2_1348(2)) { + jj_consume_token(NONE); + } else if (jj_2_1349(2)) { + jj_consume_token(NTH_VALUE); + } else if (jj_2_1350(2)) { + jj_consume_token(NUMERIC); + } else if (jj_2_1351(2)) { + jj_consume_token(OCTET_LENGTH); + } else if (jj_2_1352(2)) { + jj_consume_token(OMIT); + } else if (jj_2_1353(2)) { + jj_consume_token(OPEN); + } else if (jj_2_1354(2)) { + jj_consume_token(ORDINALITY); + } else if (jj_2_1355(2)) { + jj_consume_token(OVERLAPS); + } else if (jj_2_1356(2)) { + jj_consume_token(PARAMETER); + } else if (jj_2_1357(2)) { + jj_consume_token(PER); + } else if (jj_2_1358(2)) { + jj_consume_token(PERCENTILE_DISC); + } else if (jj_2_1359(2)) { + jj_consume_token(PERMUTE); + } else if (jj_2_1360(2)) { + jj_consume_token(POSITION_REGEX); + } else if (jj_2_1361(2)) { + jj_consume_token(PRECISION); + } else if (jj_2_1362(2)) { + jj_consume_token(PREV); + } else if (jj_2_1363(2)) { + jj_consume_token(PROCEDURE); + } else if (jj_2_1364(2)) { + jj_consume_token(RANK); + } else if (jj_2_1365(2)) { + jj_consume_token(REAL); + } else if (jj_2_1366(2)) { + jj_consume_token(REFERENCES); + } else if (jj_2_1367(2)) { + jj_consume_token(REGR_AVGY); + } else if (jj_2_1368(2)) { + jj_consume_token(REGR_R2); + } else if (jj_2_1369(2)) { + jj_consume_token(REGR_SXY); + } else if (jj_2_1370(2)) { + jj_consume_token(RELEASE); + } else if (jj_2_1371(2)) { + jj_consume_token(RESTRICT); + } else if (jj_2_1372(2)) { + jj_consume_token(RETURNS); + } else if (jj_2_1373(2)) { + jj_consume_token(ROLLBACK); + } else if (jj_2_1374(2)) { + jj_consume_token(RUNNING); + } else if (jj_2_1375(2)) { + jj_consume_token(SCOPE); + } else if (jj_2_1376(2)) { + jj_consume_token(SECOND); + } else if (jj_2_1377(2)) { + jj_consume_token(SENSITIVE); + } else if (jj_2_1378(2)) { + jj_consume_token(SHOW); + } else if (jj_2_1379(2)) { + jj_consume_token(SMALLINT); + } else if (jj_2_1380(2)) { + jj_consume_token(SPECIFICTYPE); + } else if (jj_2_1381(2)) { + jj_consume_token(SQLSTATE); + } else if (jj_2_1382(2)) { + jj_consume_token(START); + } else if (jj_2_1383(2)) { + jj_consume_token(STDDEV_POP); + } else if (jj_2_1384(2)) { + jj_consume_token(SUBSET); + } else if (jj_2_1385(2)) { + jj_consume_token(SUCCEEDS); + } else if (jj_2_1386(2)) { + jj_consume_token(SYSTEM); + } else if (jj_2_1387(2)) { + jj_consume_token(TEMPORARY); + } else if (jj_2_1388(2)) { + jj_consume_token(TINYINT); + } else if (jj_2_1389(2)) { + jj_consume_token(TRANSACTION); + } else if (jj_2_1390(2)) { + jj_consume_token(TRANSLATION); + } else if (jj_2_1391(2)) { + jj_consume_token(TRIM); + } else if (jj_2_1392(2)) { + jj_consume_token(TRUNCATE); + } else if (jj_2_1393(2)) { + jj_consume_token(UNIQUE); + } else if (jj_2_1394(2)) { + jj_consume_token(UPSERT); + } else if (jj_2_1395(2)) { + jj_consume_token(VALUE); + } else if (jj_2_1396(2)) { + jj_consume_token(VARCHAR); + } else if (jj_2_1397(2)) { + jj_consume_token(VAR_SAMP); + } else if (jj_2_1398(2)) { + jj_consume_token(VIEW); + } else if (jj_2_1399(2)) { + jj_consume_token(WIDTH_BUCKET); + } else if (jj_2_1400(2)) { + jj_consume_token(WORK); + } else if (jj_2_1401(2)) { + jj_consume_token(ZONE); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + +/** + * Defines a production which can never be accepted by the parser. + * In effect, it tells the parser, "If you got here, you've gone too far." + * It is used as the default production for parser extension points; + * derived parsers replace it with a real production when they want to + * implement a particular extension point. + */ + final public void UnusedExtension() throws ParseException { + if (false) { + + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(ZONE); + } + + final private boolean jj_2_1(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(0, xla); } + } + + final private boolean jj_2_2(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_2(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1, xla); } + } + + final private boolean jj_2_3(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_3(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(2, xla); } + } + + final private boolean jj_2_4(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_4(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(3, xla); } + } + + final private boolean jj_2_5(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_5(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(4, xla); } + } + + final private boolean jj_2_6(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_6(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(5, xla); } + } + + final private boolean jj_2_7(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_7(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(6, xla); } + } + + final private boolean jj_2_8(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_8(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(7, xla); } + } + + final private boolean jj_2_9(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_9(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(8, xla); } + } + + final private boolean jj_2_10(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_10(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(9, xla); } + } + + final private boolean jj_2_11(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_11(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(10, xla); } + } + + final private boolean jj_2_12(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_12(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(11, xla); } + } + + final private boolean jj_2_13(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_13(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(12, xla); } + } + + final private boolean jj_2_14(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_14(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(13, xla); } + } + + final private boolean jj_2_15(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_15(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(14, xla); } + } + + final private boolean jj_2_16(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_16(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(15, xla); } + } + + final private boolean jj_2_17(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_17(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(16, xla); } + } + + final private boolean jj_2_18(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_18(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(17, xla); } + } + + final private boolean jj_2_19(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_19(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(18, xla); } + } + + final private boolean jj_2_20(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_20(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(19, xla); } + } + + final private boolean jj_2_21(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_21(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(20, xla); } + } + + final private boolean jj_2_22(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_22(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(21, xla); } + } + + final private boolean jj_2_23(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_23(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(22, xla); } + } + + final private boolean jj_2_24(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_24(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(23, xla); } + } + + final private boolean jj_2_25(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_25(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(24, xla); } + } + + final private boolean jj_2_26(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_26(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(25, xla); } + } + + final private boolean jj_2_27(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_27(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(26, xla); } + } + + final private boolean jj_2_28(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_28(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(27, xla); } + } + + final private boolean jj_2_29(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_29(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(28, xla); } + } + + final private boolean jj_2_30(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_30(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(29, xla); } + } + + final private boolean jj_2_31(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_31(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(30, xla); } + } + + final private boolean jj_2_32(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_32(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(31, xla); } + } + + final private boolean jj_2_33(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_33(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(32, xla); } + } + + final private boolean jj_2_34(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_34(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(33, xla); } + } + + final private boolean jj_2_35(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_35(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(34, xla); } + } + + final private boolean jj_2_36(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_36(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(35, xla); } + } + + final private boolean jj_2_37(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_37(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(36, xla); } + } + + final private boolean jj_2_38(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_38(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(37, xla); } + } + + final private boolean jj_2_39(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_39(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(38, xla); } + } + + final private boolean jj_2_40(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_40(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(39, xla); } + } + + final private boolean jj_2_41(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_41(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(40, xla); } + } + + final private boolean jj_2_42(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_42(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(41, xla); } + } + + final private boolean jj_2_43(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_43(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(42, xla); } + } + + final private boolean jj_2_44(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_44(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(43, xla); } + } + + final private boolean jj_2_45(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_45(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(44, xla); } + } + + final private boolean jj_2_46(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_46(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(45, xla); } + } + + final private boolean jj_2_47(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_47(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(46, xla); } + } + + final private boolean jj_2_48(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_48(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(47, xla); } + } + + final private boolean jj_2_49(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_49(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(48, xla); } + } + + final private boolean jj_2_50(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_50(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(49, xla); } + } + + final private boolean jj_2_51(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_51(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(50, xla); } + } + + final private boolean jj_2_52(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_52(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(51, xla); } + } + + final private boolean jj_2_53(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_53(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(52, xla); } + } + + final private boolean jj_2_54(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_54(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(53, xla); } + } + + final private boolean jj_2_55(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_55(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(54, xla); } + } + + final private boolean jj_2_56(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_56(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(55, xla); } + } + + final private boolean jj_2_57(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_57(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(56, xla); } + } + + final private boolean jj_2_58(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_58(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(57, xla); } + } + + final private boolean jj_2_59(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_59(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(58, xla); } + } + + final private boolean jj_2_60(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_60(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(59, xla); } + } + + final private boolean jj_2_61(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_61(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(60, xla); } + } + + final private boolean jj_2_62(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_62(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(61, xla); } + } + + final private boolean jj_2_63(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_63(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(62, xla); } + } + + final private boolean jj_2_64(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_64(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(63, xla); } + } + + final private boolean jj_2_65(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_65(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(64, xla); } + } + + final private boolean jj_2_66(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_66(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(65, xla); } + } + + final private boolean jj_2_67(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_67(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(66, xla); } + } + + final private boolean jj_2_68(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_68(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(67, xla); } + } + + final private boolean jj_2_69(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_69(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(68, xla); } + } + + final private boolean jj_2_70(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_70(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(69, xla); } + } + + final private boolean jj_2_71(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_71(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(70, xla); } + } + + final private boolean jj_2_72(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_72(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(71, xla); } + } + + final private boolean jj_2_73(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_73(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(72, xla); } + } + + final private boolean jj_2_74(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_74(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(73, xla); } + } + + final private boolean jj_2_75(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_75(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(74, xla); } + } + + final private boolean jj_2_76(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_76(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(75, xla); } + } + + final private boolean jj_2_77(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_77(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(76, xla); } + } + + final private boolean jj_2_78(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_78(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(77, xla); } + } + + final private boolean jj_2_79(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_79(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(78, xla); } + } + + final private boolean jj_2_80(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_80(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(79, xla); } + } + + final private boolean jj_2_81(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_81(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(80, xla); } + } + + final private boolean jj_2_82(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_82(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(81, xla); } + } + + final private boolean jj_2_83(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_83(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(82, xla); } + } + + final private boolean jj_2_84(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_84(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(83, xla); } + } + + final private boolean jj_2_85(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_85(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(84, xla); } + } + + final private boolean jj_2_86(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_86(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(85, xla); } + } + + final private boolean jj_2_87(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_87(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(86, xla); } + } + + final private boolean jj_2_88(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_88(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(87, xla); } + } + + final private boolean jj_2_89(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_89(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(88, xla); } + } + + final private boolean jj_2_90(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_90(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(89, xla); } + } + + final private boolean jj_2_91(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_91(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(90, xla); } + } + + final private boolean jj_2_92(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_92(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(91, xla); } + } + + final private boolean jj_2_93(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_93(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(92, xla); } + } + + final private boolean jj_2_94(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_94(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(93, xla); } + } + + final private boolean jj_2_95(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_95(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(94, xla); } + } + + final private boolean jj_2_96(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_96(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(95, xla); } + } + + final private boolean jj_2_97(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_97(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(96, xla); } + } + + final private boolean jj_2_98(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_98(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(97, xla); } + } + + final private boolean jj_2_99(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_99(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(98, xla); } + } + + final private boolean jj_2_100(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_100(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(99, xla); } + } + + final private boolean jj_2_101(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_101(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(100, xla); } + } + + final private boolean jj_2_102(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_102(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(101, xla); } + } + + final private boolean jj_2_103(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_103(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(102, xla); } + } + + final private boolean jj_2_104(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_104(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(103, xla); } + } + + final private boolean jj_2_105(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_105(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(104, xla); } + } + + final private boolean jj_2_106(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_106(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(105, xla); } + } + + final private boolean jj_2_107(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_107(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(106, xla); } + } + + final private boolean jj_2_108(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_108(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(107, xla); } + } + + final private boolean jj_2_109(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_109(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(108, xla); } + } + + final private boolean jj_2_110(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_110(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(109, xla); } + } + + final private boolean jj_2_111(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_111(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(110, xla); } + } + + final private boolean jj_2_112(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_112(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(111, xla); } + } + + final private boolean jj_2_113(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_113(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(112, xla); } + } + + final private boolean jj_2_114(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_114(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(113, xla); } + } + + final private boolean jj_2_115(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_115(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(114, xla); } + } + + final private boolean jj_2_116(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_116(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(115, xla); } + } + + final private boolean jj_2_117(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_117(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(116, xla); } + } + + final private boolean jj_2_118(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_118(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(117, xla); } + } + + final private boolean jj_2_119(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_119(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(118, xla); } + } + + final private boolean jj_2_120(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_120(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(119, xla); } + } + + final private boolean jj_2_121(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_121(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(120, xla); } + } + + final private boolean jj_2_122(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_122(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(121, xla); } + } + + final private boolean jj_2_123(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_123(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(122, xla); } + } + + final private boolean jj_2_124(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_124(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(123, xla); } + } + + final private boolean jj_2_125(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_125(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(124, xla); } + } + + final private boolean jj_2_126(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_126(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(125, xla); } + } + + final private boolean jj_2_127(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_127(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(126, xla); } + } + + final private boolean jj_2_128(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_128(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(127, xla); } + } + + final private boolean jj_2_129(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_129(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(128, xla); } + } + + final private boolean jj_2_130(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_130(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(129, xla); } + } + + final private boolean jj_2_131(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_131(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(130, xla); } + } + + final private boolean jj_2_132(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_132(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(131, xla); } + } + + final private boolean jj_2_133(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_133(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(132, xla); } + } + + final private boolean jj_2_134(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_134(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(133, xla); } + } + + final private boolean jj_2_135(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_135(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(134, xla); } + } + + final private boolean jj_2_136(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_136(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(135, xla); } + } + + final private boolean jj_2_137(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_137(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(136, xla); } + } + + final private boolean jj_2_138(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_138(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(137, xla); } + } + + final private boolean jj_2_139(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_139(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(138, xla); } + } + + final private boolean jj_2_140(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_140(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(139, xla); } + } + + final private boolean jj_2_141(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_141(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(140, xla); } + } + + final private boolean jj_2_142(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_142(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(141, xla); } + } + + final private boolean jj_2_143(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_143(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(142, xla); } + } + + final private boolean jj_2_144(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_144(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(143, xla); } + } + + final private boolean jj_2_145(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_145(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(144, xla); } + } + + final private boolean jj_2_146(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_146(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(145, xla); } + } + + final private boolean jj_2_147(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_147(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(146, xla); } + } + + final private boolean jj_2_148(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_148(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(147, xla); } + } + + final private boolean jj_2_149(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_149(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(148, xla); } + } + + final private boolean jj_2_150(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_150(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(149, xla); } + } + + final private boolean jj_2_151(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_151(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(150, xla); } + } + + final private boolean jj_2_152(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_152(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(151, xla); } + } + + final private boolean jj_2_153(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_153(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(152, xla); } + } + + final private boolean jj_2_154(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_154(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(153, xla); } + } + + final private boolean jj_2_155(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_155(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(154, xla); } + } + + final private boolean jj_2_156(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_156(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(155, xla); } + } + + final private boolean jj_2_157(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_157(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(156, xla); } + } + + final private boolean jj_2_158(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_158(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(157, xla); } + } + + final private boolean jj_2_159(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_159(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(158, xla); } + } + + final private boolean jj_2_160(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_160(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(159, xla); } + } + + final private boolean jj_2_161(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_161(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(160, xla); } + } + + final private boolean jj_2_162(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_162(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(161, xla); } + } + + final private boolean jj_2_163(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_163(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(162, xla); } + } + + final private boolean jj_2_164(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_164(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(163, xla); } + } + + final private boolean jj_2_165(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_165(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(164, xla); } + } + + final private boolean jj_2_166(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_166(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(165, xla); } + } + + final private boolean jj_2_167(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_167(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(166, xla); } + } + + final private boolean jj_2_168(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_168(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(167, xla); } + } + + final private boolean jj_2_169(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_169(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(168, xla); } + } + + final private boolean jj_2_170(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_170(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(169, xla); } + } + + final private boolean jj_2_171(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_171(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(170, xla); } + } + + final private boolean jj_2_172(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_172(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(171, xla); } + } + + final private boolean jj_2_173(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_173(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(172, xla); } + } + + final private boolean jj_2_174(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_174(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(173, xla); } + } + + final private boolean jj_2_175(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_175(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(174, xla); } + } + + final private boolean jj_2_176(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_176(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(175, xla); } + } + + final private boolean jj_2_177(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_177(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(176, xla); } + } + + final private boolean jj_2_178(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_178(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(177, xla); } + } + + final private boolean jj_2_179(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_179(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(178, xla); } + } + + final private boolean jj_2_180(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_180(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(179, xla); } + } + + final private boolean jj_2_181(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_181(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(180, xla); } + } + + final private boolean jj_2_182(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_182(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(181, xla); } + } + + final private boolean jj_2_183(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_183(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(182, xla); } + } + + final private boolean jj_2_184(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_184(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(183, xla); } + } + + final private boolean jj_2_185(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_185(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(184, xla); } + } + + final private boolean jj_2_186(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_186(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(185, xla); } + } + + final private boolean jj_2_187(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_187(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(186, xla); } + } + + final private boolean jj_2_188(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_188(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(187, xla); } + } + + final private boolean jj_2_189(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_189(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(188, xla); } + } + + final private boolean jj_2_190(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_190(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(189, xla); } + } + + final private boolean jj_2_191(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_191(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(190, xla); } + } + + final private boolean jj_2_192(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_192(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(191, xla); } + } + + final private boolean jj_2_193(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_193(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(192, xla); } + } + + final private boolean jj_2_194(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_194(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(193, xla); } + } + + final private boolean jj_2_195(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_195(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(194, xla); } + } + + final private boolean jj_2_196(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_196(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(195, xla); } + } + + final private boolean jj_2_197(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_197(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(196, xla); } + } + + final private boolean jj_2_198(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_198(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(197, xla); } + } + + final private boolean jj_2_199(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_199(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(198, xla); } + } + + final private boolean jj_2_200(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_200(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(199, xla); } + } + + final private boolean jj_2_201(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_201(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(200, xla); } + } + + final private boolean jj_2_202(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_202(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(201, xla); } + } + + final private boolean jj_2_203(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_203(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(202, xla); } + } + + final private boolean jj_2_204(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_204(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(203, xla); } + } + + final private boolean jj_2_205(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_205(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(204, xla); } + } + + final private boolean jj_2_206(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_206(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(205, xla); } + } + + final private boolean jj_2_207(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_207(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(206, xla); } + } + + final private boolean jj_2_208(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_208(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(207, xla); } + } + + final private boolean jj_2_209(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_209(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(208, xla); } + } + + final private boolean jj_2_210(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_210(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(209, xla); } + } + + final private boolean jj_2_211(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_211(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(210, xla); } + } + + final private boolean jj_2_212(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_212(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(211, xla); } + } + + final private boolean jj_2_213(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_213(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(212, xla); } + } + + final private boolean jj_2_214(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_214(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(213, xla); } + } + + final private boolean jj_2_215(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_215(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(214, xla); } + } + + final private boolean jj_2_216(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_216(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(215, xla); } + } + + final private boolean jj_2_217(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_217(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(216, xla); } + } + + final private boolean jj_2_218(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_218(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(217, xla); } + } + + final private boolean jj_2_219(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_219(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(218, xla); } + } + + final private boolean jj_2_220(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_220(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(219, xla); } + } + + final private boolean jj_2_221(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_221(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(220, xla); } + } + + final private boolean jj_2_222(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_222(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(221, xla); } + } + + final private boolean jj_2_223(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_223(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(222, xla); } + } + + final private boolean jj_2_224(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_224(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(223, xla); } + } + + final private boolean jj_2_225(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_225(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(224, xla); } + } + + final private boolean jj_2_226(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_226(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(225, xla); } + } + + final private boolean jj_2_227(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_227(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(226, xla); } + } + + final private boolean jj_2_228(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_228(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(227, xla); } + } + + final private boolean jj_2_229(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_229(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(228, xla); } + } + + final private boolean jj_2_230(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_230(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(229, xla); } + } + + final private boolean jj_2_231(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_231(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(230, xla); } + } + + final private boolean jj_2_232(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_232(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(231, xla); } + } + + final private boolean jj_2_233(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_233(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(232, xla); } + } + + final private boolean jj_2_234(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_234(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(233, xla); } + } + + final private boolean jj_2_235(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_235(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(234, xla); } + } + + final private boolean jj_2_236(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_236(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(235, xla); } + } + + final private boolean jj_2_237(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_237(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(236, xla); } + } + + final private boolean jj_2_238(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_238(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(237, xla); } + } + + final private boolean jj_2_239(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_239(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(238, xla); } + } + + final private boolean jj_2_240(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_240(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(239, xla); } + } + + final private boolean jj_2_241(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_241(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(240, xla); } + } + + final private boolean jj_2_242(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_242(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(241, xla); } + } + + final private boolean jj_2_243(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_243(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(242, xla); } + } + + final private boolean jj_2_244(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_244(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(243, xla); } + } + + final private boolean jj_2_245(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_245(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(244, xla); } + } + + final private boolean jj_2_246(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_246(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(245, xla); } + } + + final private boolean jj_2_247(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_247(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(246, xla); } + } + + final private boolean jj_2_248(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_248(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(247, xla); } + } + + final private boolean jj_2_249(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_249(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(248, xla); } + } + + final private boolean jj_2_250(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_250(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(249, xla); } + } + + final private boolean jj_2_251(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_251(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(250, xla); } + } + + final private boolean jj_2_252(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_252(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(251, xla); } + } + + final private boolean jj_2_253(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_253(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(252, xla); } + } + + final private boolean jj_2_254(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_254(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(253, xla); } + } + + final private boolean jj_2_255(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_255(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(254, xla); } + } + + final private boolean jj_2_256(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_256(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(255, xla); } + } + + final private boolean jj_2_257(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_257(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(256, xla); } + } + + final private boolean jj_2_258(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_258(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(257, xla); } + } + + final private boolean jj_2_259(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_259(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(258, xla); } + } + + final private boolean jj_2_260(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_260(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(259, xla); } + } + + final private boolean jj_2_261(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_261(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(260, xla); } + } + + final private boolean jj_2_262(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_262(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(261, xla); } + } + + final private boolean jj_2_263(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_263(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(262, xla); } + } + + final private boolean jj_2_264(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_264(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(263, xla); } + } + + final private boolean jj_2_265(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_265(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(264, xla); } + } + + final private boolean jj_2_266(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_266(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(265, xla); } + } + + final private boolean jj_2_267(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_267(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(266, xla); } + } + + final private boolean jj_2_268(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_268(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(267, xla); } + } + + final private boolean jj_2_269(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_269(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(268, xla); } + } + + final private boolean jj_2_270(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_270(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(269, xla); } + } + + final private boolean jj_2_271(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_271(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(270, xla); } + } + + final private boolean jj_2_272(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_272(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(271, xla); } + } + + final private boolean jj_2_273(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_273(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(272, xla); } + } + + final private boolean jj_2_274(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_274(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(273, xla); } + } + + final private boolean jj_2_275(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_275(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(274, xla); } + } + + final private boolean jj_2_276(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_276(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(275, xla); } + } + + final private boolean jj_2_277(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_277(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(276, xla); } + } + + final private boolean jj_2_278(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_278(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(277, xla); } + } + + final private boolean jj_2_279(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_279(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(278, xla); } + } + + final private boolean jj_2_280(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_280(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(279, xla); } + } + + final private boolean jj_2_281(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_281(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(280, xla); } + } + + final private boolean jj_2_282(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_282(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(281, xla); } + } + + final private boolean jj_2_283(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_283(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(282, xla); } + } + + final private boolean jj_2_284(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_284(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(283, xla); } + } + + final private boolean jj_2_285(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_285(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(284, xla); } + } + + final private boolean jj_2_286(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_286(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(285, xla); } + } + + final private boolean jj_2_287(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_287(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(286, xla); } + } + + final private boolean jj_2_288(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_288(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(287, xla); } + } + + final private boolean jj_2_289(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_289(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(288, xla); } + } + + final private boolean jj_2_290(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_290(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(289, xla); } + } + + final private boolean jj_2_291(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_291(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(290, xla); } + } + + final private boolean jj_2_292(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_292(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(291, xla); } + } + + final private boolean jj_2_293(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_293(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(292, xla); } + } + + final private boolean jj_2_294(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_294(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(293, xla); } + } + + final private boolean jj_2_295(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_295(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(294, xla); } + } + + final private boolean jj_2_296(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_296(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(295, xla); } + } + + final private boolean jj_2_297(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_297(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(296, xla); } + } + + final private boolean jj_2_298(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_298(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(297, xla); } + } + + final private boolean jj_2_299(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_299(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(298, xla); } + } + + final private boolean jj_2_300(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_300(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(299, xla); } + } + + final private boolean jj_2_301(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_301(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(300, xla); } + } + + final private boolean jj_2_302(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_302(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(301, xla); } + } + + final private boolean jj_2_303(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_303(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(302, xla); } + } + + final private boolean jj_2_304(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_304(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(303, xla); } + } + + final private boolean jj_2_305(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_305(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(304, xla); } + } + + final private boolean jj_2_306(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_306(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(305, xla); } + } + + final private boolean jj_2_307(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_307(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(306, xla); } + } + + final private boolean jj_2_308(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_308(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(307, xla); } + } + + final private boolean jj_2_309(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_309(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(308, xla); } + } + + final private boolean jj_2_310(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_310(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(309, xla); } + } + + final private boolean jj_2_311(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_311(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(310, xla); } + } + + final private boolean jj_2_312(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_312(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(311, xla); } + } + + final private boolean jj_2_313(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_313(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(312, xla); } + } + + final private boolean jj_2_314(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_314(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(313, xla); } + } + + final private boolean jj_2_315(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_315(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(314, xla); } + } + + final private boolean jj_2_316(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_316(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(315, xla); } + } + + final private boolean jj_2_317(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_317(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(316, xla); } + } + + final private boolean jj_2_318(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_318(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(317, xla); } + } + + final private boolean jj_2_319(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_319(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(318, xla); } + } + + final private boolean jj_2_320(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_320(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(319, xla); } + } + + final private boolean jj_2_321(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_321(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(320, xla); } + } + + final private boolean jj_2_322(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_322(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(321, xla); } + } + + final private boolean jj_2_323(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_323(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(322, xla); } + } + + final private boolean jj_2_324(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_324(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(323, xla); } + } + + final private boolean jj_2_325(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_325(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(324, xla); } + } + + final private boolean jj_2_326(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_326(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(325, xla); } + } + + final private boolean jj_2_327(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_327(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(326, xla); } + } + + final private boolean jj_2_328(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_328(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(327, xla); } + } + + final private boolean jj_2_329(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_329(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(328, xla); } + } + + final private boolean jj_2_330(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_330(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(329, xla); } + } + + final private boolean jj_2_331(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_331(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(330, xla); } + } + + final private boolean jj_2_332(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_332(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(331, xla); } + } + + final private boolean jj_2_333(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_333(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(332, xla); } + } + + final private boolean jj_2_334(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_334(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(333, xla); } + } + + final private boolean jj_2_335(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_335(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(334, xla); } + } + + final private boolean jj_2_336(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_336(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(335, xla); } + } + + final private boolean jj_2_337(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_337(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(336, xla); } + } + + final private boolean jj_2_338(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_338(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(337, xla); } + } + + final private boolean jj_2_339(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_339(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(338, xla); } + } + + final private boolean jj_2_340(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_340(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(339, xla); } + } + + final private boolean jj_2_341(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_341(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(340, xla); } + } + + final private boolean jj_2_342(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_342(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(341, xla); } + } + + final private boolean jj_2_343(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_343(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(342, xla); } + } + + final private boolean jj_2_344(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_344(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(343, xla); } + } + + final private boolean jj_2_345(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_345(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(344, xla); } + } + + final private boolean jj_2_346(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_346(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(345, xla); } + } + + final private boolean jj_2_347(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_347(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(346, xla); } + } + + final private boolean jj_2_348(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_348(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(347, xla); } + } + + final private boolean jj_2_349(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_349(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(348, xla); } + } + + final private boolean jj_2_350(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_350(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(349, xla); } + } + + final private boolean jj_2_351(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_351(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(350, xla); } + } + + final private boolean jj_2_352(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_352(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(351, xla); } + } + + final private boolean jj_2_353(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_353(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(352, xla); } + } + + final private boolean jj_2_354(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_354(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(353, xla); } + } + + final private boolean jj_2_355(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_355(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(354, xla); } + } + + final private boolean jj_2_356(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_356(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(355, xla); } + } + + final private boolean jj_2_357(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_357(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(356, xla); } + } + + final private boolean jj_2_358(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_358(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(357, xla); } + } + + final private boolean jj_2_359(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_359(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(358, xla); } + } + + final private boolean jj_2_360(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_360(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(359, xla); } + } + + final private boolean jj_2_361(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_361(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(360, xla); } + } + + final private boolean jj_2_362(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_362(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(361, xla); } + } + + final private boolean jj_2_363(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_363(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(362, xla); } + } + + final private boolean jj_2_364(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_364(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(363, xla); } + } + + final private boolean jj_2_365(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_365(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(364, xla); } + } + + final private boolean jj_2_366(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_366(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(365, xla); } + } + + final private boolean jj_2_367(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_367(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(366, xla); } + } + + final private boolean jj_2_368(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_368(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(367, xla); } + } + + final private boolean jj_2_369(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_369(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(368, xla); } + } + + final private boolean jj_2_370(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_370(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(369, xla); } + } + + final private boolean jj_2_371(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_371(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(370, xla); } + } + + final private boolean jj_2_372(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_372(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(371, xla); } + } + + final private boolean jj_2_373(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_373(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(372, xla); } + } + + final private boolean jj_2_374(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_374(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(373, xla); } + } + + final private boolean jj_2_375(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_375(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(374, xla); } + } + + final private boolean jj_2_376(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_376(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(375, xla); } + } + + final private boolean jj_2_377(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_377(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(376, xla); } + } + + final private boolean jj_2_378(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_378(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(377, xla); } + } + + final private boolean jj_2_379(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_379(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(378, xla); } + } + + final private boolean jj_2_380(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_380(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(379, xla); } + } + + final private boolean jj_2_381(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_381(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(380, xla); } + } + + final private boolean jj_2_382(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_382(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(381, xla); } + } + + final private boolean jj_2_383(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_383(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(382, xla); } + } + + final private boolean jj_2_384(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_384(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(383, xla); } + } + + final private boolean jj_2_385(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_385(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(384, xla); } + } + + final private boolean jj_2_386(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_386(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(385, xla); } + } + + final private boolean jj_2_387(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_387(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(386, xla); } + } + + final private boolean jj_2_388(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_388(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(387, xla); } + } + + final private boolean jj_2_389(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_389(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(388, xla); } + } + + final private boolean jj_2_390(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_390(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(389, xla); } + } + + final private boolean jj_2_391(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_391(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(390, xla); } + } + + final private boolean jj_2_392(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_392(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(391, xla); } + } + + final private boolean jj_2_393(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_393(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(392, xla); } + } + + final private boolean jj_2_394(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_394(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(393, xla); } + } + + final private boolean jj_2_395(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_395(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(394, xla); } + } + + final private boolean jj_2_396(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_396(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(395, xla); } + } + + final private boolean jj_2_397(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_397(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(396, xla); } + } + + final private boolean jj_2_398(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_398(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(397, xla); } + } + + final private boolean jj_2_399(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_399(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(398, xla); } + } + + final private boolean jj_2_400(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_400(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(399, xla); } + } + + final private boolean jj_2_401(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_401(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(400, xla); } + } + + final private boolean jj_2_402(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_402(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(401, xla); } + } + + final private boolean jj_2_403(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_403(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(402, xla); } + } + + final private boolean jj_2_404(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_404(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(403, xla); } + } + + final private boolean jj_2_405(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_405(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(404, xla); } + } + + final private boolean jj_2_406(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_406(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(405, xla); } + } + + final private boolean jj_2_407(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_407(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(406, xla); } + } + + final private boolean jj_2_408(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_408(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(407, xla); } + } + + final private boolean jj_2_409(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_409(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(408, xla); } + } + + final private boolean jj_2_410(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_410(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(409, xla); } + } + + final private boolean jj_2_411(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_411(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(410, xla); } + } + + final private boolean jj_2_412(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_412(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(411, xla); } + } + + final private boolean jj_2_413(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_413(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(412, xla); } + } + + final private boolean jj_2_414(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_414(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(413, xla); } + } + + final private boolean jj_2_415(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_415(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(414, xla); } + } + + final private boolean jj_2_416(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_416(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(415, xla); } + } + + final private boolean jj_2_417(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_417(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(416, xla); } + } + + final private boolean jj_2_418(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_418(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(417, xla); } + } + + final private boolean jj_2_419(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_419(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(418, xla); } + } + + final private boolean jj_2_420(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_420(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(419, xla); } + } + + final private boolean jj_2_421(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_421(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(420, xla); } + } + + final private boolean jj_2_422(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_422(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(421, xla); } + } + + final private boolean jj_2_423(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_423(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(422, xla); } + } + + final private boolean jj_2_424(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_424(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(423, xla); } + } + + final private boolean jj_2_425(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_425(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(424, xla); } + } + + final private boolean jj_2_426(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_426(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(425, xla); } + } + + final private boolean jj_2_427(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_427(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(426, xla); } + } + + final private boolean jj_2_428(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_428(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(427, xla); } + } + + final private boolean jj_2_429(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_429(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(428, xla); } + } + + final private boolean jj_2_430(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_430(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(429, xla); } + } + + final private boolean jj_2_431(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_431(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(430, xla); } + } + + final private boolean jj_2_432(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_432(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(431, xla); } + } + + final private boolean jj_2_433(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_433(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(432, xla); } + } + + final private boolean jj_2_434(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_434(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(433, xla); } + } + + final private boolean jj_2_435(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_435(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(434, xla); } + } + + final private boolean jj_2_436(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_436(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(435, xla); } + } + + final private boolean jj_2_437(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_437(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(436, xla); } + } + + final private boolean jj_2_438(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_438(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(437, xla); } + } + + final private boolean jj_2_439(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_439(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(438, xla); } + } + + final private boolean jj_2_440(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_440(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(439, xla); } + } + + final private boolean jj_2_441(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_441(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(440, xla); } + } + + final private boolean jj_2_442(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_442(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(441, xla); } + } + + final private boolean jj_2_443(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_443(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(442, xla); } + } + + final private boolean jj_2_444(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_444(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(443, xla); } + } + + final private boolean jj_2_445(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_445(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(444, xla); } + } + + final private boolean jj_2_446(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_446(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(445, xla); } + } + + final private boolean jj_2_447(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_447(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(446, xla); } + } + + final private boolean jj_2_448(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_448(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(447, xla); } + } + + final private boolean jj_2_449(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_449(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(448, xla); } + } + + final private boolean jj_2_450(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_450(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(449, xla); } + } + + final private boolean jj_2_451(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_451(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(450, xla); } + } + + final private boolean jj_2_452(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_452(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(451, xla); } + } + + final private boolean jj_2_453(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_453(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(452, xla); } + } + + final private boolean jj_2_454(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_454(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(453, xla); } + } + + final private boolean jj_2_455(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_455(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(454, xla); } + } + + final private boolean jj_2_456(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_456(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(455, xla); } + } + + final private boolean jj_2_457(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_457(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(456, xla); } + } + + final private boolean jj_2_458(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_458(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(457, xla); } + } + + final private boolean jj_2_459(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_459(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(458, xla); } + } + + final private boolean jj_2_460(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_460(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(459, xla); } + } + + final private boolean jj_2_461(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_461(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(460, xla); } + } + + final private boolean jj_2_462(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_462(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(461, xla); } + } + + final private boolean jj_2_463(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_463(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(462, xla); } + } + + final private boolean jj_2_464(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_464(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(463, xla); } + } + + final private boolean jj_2_465(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_465(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(464, xla); } + } + + final private boolean jj_2_466(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_466(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(465, xla); } + } + + final private boolean jj_2_467(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_467(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(466, xla); } + } + + final private boolean jj_2_468(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_468(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(467, xla); } + } + + final private boolean jj_2_469(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_469(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(468, xla); } + } + + final private boolean jj_2_470(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_470(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(469, xla); } + } + + final private boolean jj_2_471(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_471(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(470, xla); } + } + + final private boolean jj_2_472(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_472(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(471, xla); } + } + + final private boolean jj_2_473(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_473(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(472, xla); } + } + + final private boolean jj_2_474(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_474(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(473, xla); } + } + + final private boolean jj_2_475(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_475(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(474, xla); } + } + + final private boolean jj_2_476(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_476(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(475, xla); } + } + + final private boolean jj_2_477(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_477(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(476, xla); } + } + + final private boolean jj_2_478(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_478(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(477, xla); } + } + + final private boolean jj_2_479(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_479(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(478, xla); } + } + + final private boolean jj_2_480(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_480(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(479, xla); } + } + + final private boolean jj_2_481(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_481(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(480, xla); } + } + + final private boolean jj_2_482(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_482(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(481, xla); } + } + + final private boolean jj_2_483(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_483(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(482, xla); } + } + + final private boolean jj_2_484(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_484(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(483, xla); } + } + + final private boolean jj_2_485(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_485(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(484, xla); } + } + + final private boolean jj_2_486(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_486(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(485, xla); } + } + + final private boolean jj_2_487(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_487(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(486, xla); } + } + + final private boolean jj_2_488(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_488(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(487, xla); } + } + + final private boolean jj_2_489(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_489(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(488, xla); } + } + + final private boolean jj_2_490(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_490(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(489, xla); } + } + + final private boolean jj_2_491(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_491(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(490, xla); } + } + + final private boolean jj_2_492(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_492(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(491, xla); } + } + + final private boolean jj_2_493(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_493(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(492, xla); } + } + + final private boolean jj_2_494(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_494(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(493, xla); } + } + + final private boolean jj_2_495(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_495(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(494, xla); } + } + + final private boolean jj_2_496(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_496(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(495, xla); } + } + + final private boolean jj_2_497(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_497(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(496, xla); } + } + + final private boolean jj_2_498(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_498(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(497, xla); } + } + + final private boolean jj_2_499(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_499(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(498, xla); } + } + + final private boolean jj_2_500(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_500(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(499, xla); } + } + + final private boolean jj_2_501(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_501(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(500, xla); } + } + + final private boolean jj_2_502(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_502(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(501, xla); } + } + + final private boolean jj_2_503(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_503(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(502, xla); } + } + + final private boolean jj_2_504(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_504(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(503, xla); } + } + + final private boolean jj_2_505(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_505(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(504, xla); } + } + + final private boolean jj_2_506(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_506(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(505, xla); } + } + + final private boolean jj_2_507(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_507(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(506, xla); } + } + + final private boolean jj_2_508(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_508(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(507, xla); } + } + + final private boolean jj_2_509(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_509(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(508, xla); } + } + + final private boolean jj_2_510(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_510(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(509, xla); } + } + + final private boolean jj_2_511(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_511(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(510, xla); } + } + + final private boolean jj_2_512(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_512(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(511, xla); } + } + + final private boolean jj_2_513(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_513(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(512, xla); } + } + + final private boolean jj_2_514(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_514(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(513, xla); } + } + + final private boolean jj_2_515(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_515(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(514, xla); } + } + + final private boolean jj_2_516(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_516(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(515, xla); } + } + + final private boolean jj_2_517(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_517(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(516, xla); } + } + + final private boolean jj_2_518(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_518(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(517, xla); } + } + + final private boolean jj_2_519(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_519(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(518, xla); } + } + + final private boolean jj_2_520(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_520(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(519, xla); } + } + + final private boolean jj_2_521(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_521(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(520, xla); } + } + + final private boolean jj_2_522(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_522(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(521, xla); } + } + + final private boolean jj_2_523(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_523(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(522, xla); } + } + + final private boolean jj_2_524(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_524(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(523, xla); } + } + + final private boolean jj_2_525(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_525(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(524, xla); } + } + + final private boolean jj_2_526(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_526(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(525, xla); } + } + + final private boolean jj_2_527(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_527(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(526, xla); } + } + + final private boolean jj_2_528(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_528(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(527, xla); } + } + + final private boolean jj_2_529(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_529(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(528, xla); } + } + + final private boolean jj_2_530(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_530(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(529, xla); } + } + + final private boolean jj_2_531(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_531(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(530, xla); } + } + + final private boolean jj_2_532(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_532(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(531, xla); } + } + + final private boolean jj_2_533(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_533(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(532, xla); } + } + + final private boolean jj_2_534(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_534(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(533, xla); } + } + + final private boolean jj_2_535(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_535(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(534, xla); } + } + + final private boolean jj_2_536(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_536(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(535, xla); } + } + + final private boolean jj_2_537(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_537(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(536, xla); } + } + + final private boolean jj_2_538(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_538(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(537, xla); } + } + + final private boolean jj_2_539(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_539(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(538, xla); } + } + + final private boolean jj_2_540(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_540(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(539, xla); } + } + + final private boolean jj_2_541(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_541(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(540, xla); } + } + + final private boolean jj_2_542(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_542(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(541, xla); } + } + + final private boolean jj_2_543(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_543(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(542, xla); } + } + + final private boolean jj_2_544(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_544(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(543, xla); } + } + + final private boolean jj_2_545(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_545(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(544, xla); } + } + + final private boolean jj_2_546(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_546(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(545, xla); } + } + + final private boolean jj_2_547(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_547(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(546, xla); } + } + + final private boolean jj_2_548(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_548(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(547, xla); } + } + + final private boolean jj_2_549(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_549(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(548, xla); } + } + + final private boolean jj_2_550(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_550(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(549, xla); } + } + + final private boolean jj_2_551(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_551(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(550, xla); } + } + + final private boolean jj_2_552(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_552(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(551, xla); } + } + + final private boolean jj_2_553(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_553(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(552, xla); } + } + + final private boolean jj_2_554(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_554(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(553, xla); } + } + + final private boolean jj_2_555(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_555(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(554, xla); } + } + + final private boolean jj_2_556(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_556(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(555, xla); } + } + + final private boolean jj_2_557(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_557(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(556, xla); } + } + + final private boolean jj_2_558(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_558(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(557, xla); } + } + + final private boolean jj_2_559(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_559(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(558, xla); } + } + + final private boolean jj_2_560(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_560(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(559, xla); } + } + + final private boolean jj_2_561(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_561(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(560, xla); } + } + + final private boolean jj_2_562(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_562(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(561, xla); } + } + + final private boolean jj_2_563(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_563(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(562, xla); } + } + + final private boolean jj_2_564(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_564(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(563, xla); } + } + + final private boolean jj_2_565(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_565(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(564, xla); } + } + + final private boolean jj_2_566(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_566(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(565, xla); } + } + + final private boolean jj_2_567(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_567(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(566, xla); } + } + + final private boolean jj_2_568(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_568(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(567, xla); } + } + + final private boolean jj_2_569(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_569(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(568, xla); } + } + + final private boolean jj_2_570(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_570(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(569, xla); } + } + + final private boolean jj_2_571(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_571(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(570, xla); } + } + + final private boolean jj_2_572(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_572(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(571, xla); } + } + + final private boolean jj_2_573(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_573(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(572, xla); } + } + + final private boolean jj_2_574(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_574(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(573, xla); } + } + + final private boolean jj_2_575(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_575(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(574, xla); } + } + + final private boolean jj_2_576(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_576(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(575, xla); } + } + + final private boolean jj_2_577(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_577(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(576, xla); } + } + + final private boolean jj_2_578(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_578(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(577, xla); } + } + + final private boolean jj_2_579(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_579(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(578, xla); } + } + + final private boolean jj_2_580(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_580(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(579, xla); } + } + + final private boolean jj_2_581(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_581(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(580, xla); } + } + + final private boolean jj_2_582(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_582(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(581, xla); } + } + + final private boolean jj_2_583(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_583(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(582, xla); } + } + + final private boolean jj_2_584(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_584(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(583, xla); } + } + + final private boolean jj_2_585(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_585(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(584, xla); } + } + + final private boolean jj_2_586(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_586(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(585, xla); } + } + + final private boolean jj_2_587(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_587(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(586, xla); } + } + + final private boolean jj_2_588(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_588(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(587, xla); } + } + + final private boolean jj_2_589(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_589(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(588, xla); } + } + + final private boolean jj_2_590(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_590(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(589, xla); } + } + + final private boolean jj_2_591(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_591(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(590, xla); } + } + + final private boolean jj_2_592(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_592(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(591, xla); } + } + + final private boolean jj_2_593(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_593(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(592, xla); } + } + + final private boolean jj_2_594(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_594(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(593, xla); } + } + + final private boolean jj_2_595(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_595(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(594, xla); } + } + + final private boolean jj_2_596(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_596(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(595, xla); } + } + + final private boolean jj_2_597(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_597(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(596, xla); } + } + + final private boolean jj_2_598(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_598(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(597, xla); } + } + + final private boolean jj_2_599(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_599(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(598, xla); } + } + + final private boolean jj_2_600(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_600(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(599, xla); } + } + + final private boolean jj_2_601(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_601(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(600, xla); } + } + + final private boolean jj_2_602(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_602(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(601, xla); } + } + + final private boolean jj_2_603(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_603(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(602, xla); } + } + + final private boolean jj_2_604(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_604(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(603, xla); } + } + + final private boolean jj_2_605(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_605(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(604, xla); } + } + + final private boolean jj_2_606(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_606(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(605, xla); } + } + + final private boolean jj_2_607(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_607(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(606, xla); } + } + + final private boolean jj_2_608(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_608(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(607, xla); } + } + + final private boolean jj_2_609(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_609(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(608, xla); } + } + + final private boolean jj_2_610(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_610(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(609, xla); } + } + + final private boolean jj_2_611(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_611(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(610, xla); } + } + + final private boolean jj_2_612(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_612(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(611, xla); } + } + + final private boolean jj_2_613(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_613(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(612, xla); } + } + + final private boolean jj_2_614(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_614(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(613, xla); } + } + + final private boolean jj_2_615(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_615(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(614, xla); } + } + + final private boolean jj_2_616(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_616(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(615, xla); } + } + + final private boolean jj_2_617(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_617(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(616, xla); } + } + + final private boolean jj_2_618(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_618(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(617, xla); } + } + + final private boolean jj_2_619(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_619(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(618, xla); } + } + + final private boolean jj_2_620(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_620(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(619, xla); } + } + + final private boolean jj_2_621(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_621(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(620, xla); } + } + + final private boolean jj_2_622(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_622(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(621, xla); } + } + + final private boolean jj_2_623(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_623(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(622, xla); } + } + + final private boolean jj_2_624(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_624(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(623, xla); } + } + + final private boolean jj_2_625(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_625(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(624, xla); } + } + + final private boolean jj_2_626(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_626(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(625, xla); } + } + + final private boolean jj_2_627(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_627(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(626, xla); } + } + + final private boolean jj_2_628(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_628(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(627, xla); } + } + + final private boolean jj_2_629(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_629(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(628, xla); } + } + + final private boolean jj_2_630(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_630(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(629, xla); } + } + + final private boolean jj_2_631(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_631(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(630, xla); } + } + + final private boolean jj_2_632(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_632(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(631, xla); } + } + + final private boolean jj_2_633(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_633(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(632, xla); } + } + + final private boolean jj_2_634(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_634(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(633, xla); } + } + + final private boolean jj_2_635(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_635(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(634, xla); } + } + + final private boolean jj_2_636(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_636(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(635, xla); } + } + + final private boolean jj_2_637(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_637(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(636, xla); } + } + + final private boolean jj_2_638(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_638(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(637, xla); } + } + + final private boolean jj_2_639(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_639(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(638, xla); } + } + + final private boolean jj_2_640(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_640(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(639, xla); } + } + + final private boolean jj_2_641(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_641(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(640, xla); } + } + + final private boolean jj_2_642(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_642(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(641, xla); } + } + + final private boolean jj_2_643(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_643(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(642, xla); } + } + + final private boolean jj_2_644(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_644(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(643, xla); } + } + + final private boolean jj_2_645(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_645(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(644, xla); } + } + + final private boolean jj_2_646(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_646(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(645, xla); } + } + + final private boolean jj_2_647(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_647(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(646, xla); } + } + + final private boolean jj_2_648(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_648(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(647, xla); } + } + + final private boolean jj_2_649(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_649(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(648, xla); } + } + + final private boolean jj_2_650(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_650(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(649, xla); } + } + + final private boolean jj_2_651(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_651(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(650, xla); } + } + + final private boolean jj_2_652(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_652(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(651, xla); } + } + + final private boolean jj_2_653(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_653(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(652, xla); } + } + + final private boolean jj_2_654(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_654(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(653, xla); } + } + + final private boolean jj_2_655(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_655(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(654, xla); } + } + + final private boolean jj_2_656(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_656(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(655, xla); } + } + + final private boolean jj_2_657(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_657(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(656, xla); } + } + + final private boolean jj_2_658(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_658(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(657, xla); } + } + + final private boolean jj_2_659(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_659(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(658, xla); } + } + + final private boolean jj_2_660(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_660(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(659, xla); } + } + + final private boolean jj_2_661(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_661(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(660, xla); } + } + + final private boolean jj_2_662(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_662(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(661, xla); } + } + + final private boolean jj_2_663(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_663(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(662, xla); } + } + + final private boolean jj_2_664(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_664(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(663, xla); } + } + + final private boolean jj_2_665(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_665(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(664, xla); } + } + + final private boolean jj_2_666(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_666(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(665, xla); } + } + + final private boolean jj_2_667(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_667(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(666, xla); } + } + + final private boolean jj_2_668(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_668(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(667, xla); } + } + + final private boolean jj_2_669(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_669(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(668, xla); } + } + + final private boolean jj_2_670(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_670(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(669, xla); } + } + + final private boolean jj_2_671(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_671(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(670, xla); } + } + + final private boolean jj_2_672(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_672(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(671, xla); } + } + + final private boolean jj_2_673(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_673(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(672, xla); } + } + + final private boolean jj_2_674(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_674(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(673, xla); } + } + + final private boolean jj_2_675(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_675(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(674, xla); } + } + + final private boolean jj_2_676(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_676(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(675, xla); } + } + + final private boolean jj_2_677(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_677(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(676, xla); } + } + + final private boolean jj_2_678(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_678(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(677, xla); } + } + + final private boolean jj_2_679(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_679(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(678, xla); } + } + + final private boolean jj_2_680(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_680(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(679, xla); } + } + + final private boolean jj_2_681(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_681(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(680, xla); } + } + + final private boolean jj_2_682(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_682(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(681, xla); } + } + + final private boolean jj_2_683(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_683(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(682, xla); } + } + + final private boolean jj_2_684(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_684(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(683, xla); } + } + + final private boolean jj_2_685(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_685(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(684, xla); } + } + + final private boolean jj_2_686(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_686(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(685, xla); } + } + + final private boolean jj_2_687(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_687(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(686, xla); } + } + + final private boolean jj_2_688(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_688(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(687, xla); } + } + + final private boolean jj_2_689(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_689(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(688, xla); } + } + + final private boolean jj_2_690(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_690(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(689, xla); } + } + + final private boolean jj_2_691(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_691(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(690, xla); } + } + + final private boolean jj_2_692(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_692(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(691, xla); } + } + + final private boolean jj_2_693(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_693(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(692, xla); } + } + + final private boolean jj_2_694(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_694(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(693, xla); } + } + + final private boolean jj_2_695(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_695(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(694, xla); } + } + + final private boolean jj_2_696(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_696(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(695, xla); } + } + + final private boolean jj_2_697(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_697(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(696, xla); } + } + + final private boolean jj_2_698(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_698(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(697, xla); } + } + + final private boolean jj_2_699(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_699(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(698, xla); } + } + + final private boolean jj_2_700(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_700(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(699, xla); } + } + + final private boolean jj_2_701(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_701(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(700, xla); } + } + + final private boolean jj_2_702(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_702(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(701, xla); } + } + + final private boolean jj_2_703(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_703(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(702, xla); } + } + + final private boolean jj_2_704(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_704(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(703, xla); } + } + + final private boolean jj_2_705(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_705(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(704, xla); } + } + + final private boolean jj_2_706(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_706(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(705, xla); } + } + + final private boolean jj_2_707(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_707(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(706, xla); } + } + + final private boolean jj_2_708(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_708(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(707, xla); } + } + + final private boolean jj_2_709(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_709(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(708, xla); } + } + + final private boolean jj_2_710(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_710(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(709, xla); } + } + + final private boolean jj_2_711(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_711(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(710, xla); } + } + + final private boolean jj_2_712(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_712(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(711, xla); } + } + + final private boolean jj_2_713(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_713(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(712, xla); } + } + + final private boolean jj_2_714(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_714(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(713, xla); } + } + + final private boolean jj_2_715(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_715(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(714, xla); } + } + + final private boolean jj_2_716(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_716(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(715, xla); } + } + + final private boolean jj_2_717(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_717(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(716, xla); } + } + + final private boolean jj_2_718(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_718(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(717, xla); } + } + + final private boolean jj_2_719(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_719(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(718, xla); } + } + + final private boolean jj_2_720(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_720(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(719, xla); } + } + + final private boolean jj_2_721(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_721(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(720, xla); } + } + + final private boolean jj_2_722(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_722(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(721, xla); } + } + + final private boolean jj_2_723(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_723(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(722, xla); } + } + + final private boolean jj_2_724(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_724(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(723, xla); } + } + + final private boolean jj_2_725(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_725(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(724, xla); } + } + + final private boolean jj_2_726(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_726(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(725, xla); } + } + + final private boolean jj_2_727(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_727(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(726, xla); } + } + + final private boolean jj_2_728(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_728(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(727, xla); } + } + + final private boolean jj_2_729(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_729(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(728, xla); } + } + + final private boolean jj_2_730(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_730(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(729, xla); } + } + + final private boolean jj_2_731(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_731(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(730, xla); } + } + + final private boolean jj_2_732(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_732(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(731, xla); } + } + + final private boolean jj_2_733(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_733(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(732, xla); } + } + + final private boolean jj_2_734(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_734(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(733, xla); } + } + + final private boolean jj_2_735(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_735(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(734, xla); } + } + + final private boolean jj_2_736(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_736(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(735, xla); } + } + + final private boolean jj_2_737(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_737(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(736, xla); } + } + + final private boolean jj_2_738(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_738(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(737, xla); } + } + + final private boolean jj_2_739(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_739(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(738, xla); } + } + + final private boolean jj_2_740(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_740(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(739, xla); } + } + + final private boolean jj_2_741(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_741(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(740, xla); } + } + + final private boolean jj_2_742(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_742(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(741, xla); } + } + + final private boolean jj_2_743(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_743(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(742, xla); } + } + + final private boolean jj_2_744(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_744(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(743, xla); } + } + + final private boolean jj_2_745(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_745(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(744, xla); } + } + + final private boolean jj_2_746(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_746(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(745, xla); } + } + + final private boolean jj_2_747(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_747(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(746, xla); } + } + + final private boolean jj_2_748(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_748(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(747, xla); } + } + + final private boolean jj_2_749(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_749(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(748, xla); } + } + + final private boolean jj_2_750(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_750(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(749, xla); } + } + + final private boolean jj_2_751(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_751(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(750, xla); } + } + + final private boolean jj_2_752(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_752(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(751, xla); } + } + + final private boolean jj_2_753(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_753(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(752, xla); } + } + + final private boolean jj_2_754(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_754(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(753, xla); } + } + + final private boolean jj_2_755(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_755(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(754, xla); } + } + + final private boolean jj_2_756(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_756(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(755, xla); } + } + + final private boolean jj_2_757(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_757(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(756, xla); } + } + + final private boolean jj_2_758(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_758(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(757, xla); } + } + + final private boolean jj_2_759(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_759(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(758, xla); } + } + + final private boolean jj_2_760(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_760(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(759, xla); } + } + + final private boolean jj_2_761(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_761(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(760, xla); } + } + + final private boolean jj_2_762(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_762(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(761, xla); } + } + + final private boolean jj_2_763(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_763(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(762, xla); } + } + + final private boolean jj_2_764(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_764(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(763, xla); } + } + + final private boolean jj_2_765(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_765(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(764, xla); } + } + + final private boolean jj_2_766(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_766(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(765, xla); } + } + + final private boolean jj_2_767(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_767(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(766, xla); } + } + + final private boolean jj_2_768(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_768(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(767, xla); } + } + + final private boolean jj_2_769(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_769(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(768, xla); } + } + + final private boolean jj_2_770(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_770(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(769, xla); } + } + + final private boolean jj_2_771(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_771(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(770, xla); } + } + + final private boolean jj_2_772(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_772(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(771, xla); } + } + + final private boolean jj_2_773(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_773(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(772, xla); } + } + + final private boolean jj_2_774(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_774(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(773, xla); } + } + + final private boolean jj_2_775(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_775(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(774, xla); } + } + + final private boolean jj_2_776(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_776(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(775, xla); } + } + + final private boolean jj_2_777(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_777(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(776, xla); } + } + + final private boolean jj_2_778(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_778(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(777, xla); } + } + + final private boolean jj_2_779(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_779(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(778, xla); } + } + + final private boolean jj_2_780(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_780(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(779, xla); } + } + + final private boolean jj_2_781(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_781(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(780, xla); } + } + + final private boolean jj_2_782(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_782(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(781, xla); } + } + + final private boolean jj_2_783(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_783(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(782, xla); } + } + + final private boolean jj_2_784(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_784(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(783, xla); } + } + + final private boolean jj_2_785(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_785(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(784, xla); } + } + + final private boolean jj_2_786(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_786(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(785, xla); } + } + + final private boolean jj_2_787(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_787(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(786, xla); } + } + + final private boolean jj_2_788(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_788(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(787, xla); } + } + + final private boolean jj_2_789(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_789(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(788, xla); } + } + + final private boolean jj_2_790(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_790(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(789, xla); } + } + + final private boolean jj_2_791(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_791(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(790, xla); } + } + + final private boolean jj_2_792(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_792(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(791, xla); } + } + + final private boolean jj_2_793(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_793(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(792, xla); } + } + + final private boolean jj_2_794(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_794(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(793, xla); } + } + + final private boolean jj_2_795(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_795(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(794, xla); } + } + + final private boolean jj_2_796(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_796(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(795, xla); } + } + + final private boolean jj_2_797(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_797(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(796, xla); } + } + + final private boolean jj_2_798(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_798(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(797, xla); } + } + + final private boolean jj_2_799(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_799(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(798, xla); } + } + + final private boolean jj_2_800(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_800(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(799, xla); } + } + + final private boolean jj_2_801(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_801(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(800, xla); } + } + + final private boolean jj_2_802(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_802(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(801, xla); } + } + + final private boolean jj_2_803(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_803(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(802, xla); } + } + + final private boolean jj_2_804(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_804(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(803, xla); } + } + + final private boolean jj_2_805(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_805(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(804, xla); } + } + + final private boolean jj_2_806(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_806(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(805, xla); } + } + + final private boolean jj_2_807(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_807(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(806, xla); } + } + + final private boolean jj_2_808(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_808(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(807, xla); } + } + + final private boolean jj_2_809(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_809(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(808, xla); } + } + + final private boolean jj_2_810(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_810(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(809, xla); } + } + + final private boolean jj_2_811(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_811(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(810, xla); } + } + + final private boolean jj_2_812(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_812(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(811, xla); } + } + + final private boolean jj_2_813(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_813(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(812, xla); } + } + + final private boolean jj_2_814(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_814(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(813, xla); } + } + + final private boolean jj_2_815(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_815(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(814, xla); } + } + + final private boolean jj_2_816(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_816(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(815, xla); } + } + + final private boolean jj_2_817(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_817(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(816, xla); } + } + + final private boolean jj_2_818(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_818(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(817, xla); } + } + + final private boolean jj_2_819(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_819(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(818, xla); } + } + + final private boolean jj_2_820(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_820(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(819, xla); } + } + + final private boolean jj_2_821(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_821(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(820, xla); } + } + + final private boolean jj_2_822(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_822(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(821, xla); } + } + + final private boolean jj_2_823(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_823(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(822, xla); } + } + + final private boolean jj_2_824(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_824(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(823, xla); } + } + + final private boolean jj_2_825(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_825(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(824, xla); } + } + + final private boolean jj_2_826(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_826(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(825, xla); } + } + + final private boolean jj_2_827(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_827(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(826, xla); } + } + + final private boolean jj_2_828(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_828(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(827, xla); } + } + + final private boolean jj_2_829(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_829(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(828, xla); } + } + + final private boolean jj_2_830(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_830(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(829, xla); } + } + + final private boolean jj_2_831(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_831(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(830, xla); } + } + + final private boolean jj_2_832(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_832(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(831, xla); } + } + + final private boolean jj_2_833(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_833(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(832, xla); } + } + + final private boolean jj_2_834(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_834(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(833, xla); } + } + + final private boolean jj_2_835(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_835(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(834, xla); } + } + + final private boolean jj_2_836(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_836(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(835, xla); } + } + + final private boolean jj_2_837(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_837(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(836, xla); } + } + + final private boolean jj_2_838(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_838(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(837, xla); } + } + + final private boolean jj_2_839(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_839(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(838, xla); } + } + + final private boolean jj_2_840(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_840(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(839, xla); } + } + + final private boolean jj_2_841(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_841(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(840, xla); } + } + + final private boolean jj_2_842(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_842(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(841, xla); } + } + + final private boolean jj_2_843(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_843(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(842, xla); } + } + + final private boolean jj_2_844(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_844(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(843, xla); } + } + + final private boolean jj_2_845(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_845(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(844, xla); } + } + + final private boolean jj_2_846(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_846(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(845, xla); } + } + + final private boolean jj_2_847(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_847(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(846, xla); } + } + + final private boolean jj_2_848(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_848(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(847, xla); } + } + + final private boolean jj_2_849(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_849(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(848, xla); } + } + + final private boolean jj_2_850(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_850(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(849, xla); } + } + + final private boolean jj_2_851(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_851(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(850, xla); } + } + + final private boolean jj_2_852(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_852(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(851, xla); } + } + + final private boolean jj_2_853(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_853(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(852, xla); } + } + + final private boolean jj_2_854(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_854(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(853, xla); } + } + + final private boolean jj_2_855(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_855(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(854, xla); } + } + + final private boolean jj_2_856(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_856(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(855, xla); } + } + + final private boolean jj_2_857(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_857(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(856, xla); } + } + + final private boolean jj_2_858(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_858(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(857, xla); } + } + + final private boolean jj_2_859(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_859(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(858, xla); } + } + + final private boolean jj_2_860(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_860(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(859, xla); } + } + + final private boolean jj_2_861(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_861(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(860, xla); } + } + + final private boolean jj_2_862(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_862(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(861, xla); } + } + + final private boolean jj_2_863(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_863(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(862, xla); } + } + + final private boolean jj_2_864(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_864(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(863, xla); } + } + + final private boolean jj_2_865(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_865(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(864, xla); } + } + + final private boolean jj_2_866(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_866(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(865, xla); } + } + + final private boolean jj_2_867(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_867(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(866, xla); } + } + + final private boolean jj_2_868(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_868(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(867, xla); } + } + + final private boolean jj_2_869(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_869(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(868, xla); } + } + + final private boolean jj_2_870(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_870(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(869, xla); } + } + + final private boolean jj_2_871(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_871(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(870, xla); } + } + + final private boolean jj_2_872(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_872(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(871, xla); } + } + + final private boolean jj_2_873(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_873(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(872, xla); } + } + + final private boolean jj_2_874(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_874(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(873, xla); } + } + + final private boolean jj_2_875(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_875(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(874, xla); } + } + + final private boolean jj_2_876(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_876(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(875, xla); } + } + + final private boolean jj_2_877(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_877(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(876, xla); } + } + + final private boolean jj_2_878(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_878(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(877, xla); } + } + + final private boolean jj_2_879(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_879(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(878, xla); } + } + + final private boolean jj_2_880(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_880(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(879, xla); } + } + + final private boolean jj_2_881(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_881(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(880, xla); } + } + + final private boolean jj_2_882(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_882(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(881, xla); } + } + + final private boolean jj_2_883(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_883(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(882, xla); } + } + + final private boolean jj_2_884(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_884(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(883, xla); } + } + + final private boolean jj_2_885(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_885(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(884, xla); } + } + + final private boolean jj_2_886(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_886(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(885, xla); } + } + + final private boolean jj_2_887(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_887(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(886, xla); } + } + + final private boolean jj_2_888(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_888(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(887, xla); } + } + + final private boolean jj_2_889(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_889(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(888, xla); } + } + + final private boolean jj_2_890(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_890(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(889, xla); } + } + + final private boolean jj_2_891(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_891(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(890, xla); } + } + + final private boolean jj_2_892(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_892(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(891, xla); } + } + + final private boolean jj_2_893(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_893(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(892, xla); } + } + + final private boolean jj_2_894(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_894(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(893, xla); } + } + + final private boolean jj_2_895(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_895(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(894, xla); } + } + + final private boolean jj_2_896(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_896(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(895, xla); } + } + + final private boolean jj_2_897(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_897(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(896, xla); } + } + + final private boolean jj_2_898(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_898(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(897, xla); } + } + + final private boolean jj_2_899(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_899(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(898, xla); } + } + + final private boolean jj_2_900(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_900(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(899, xla); } + } + + final private boolean jj_2_901(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_901(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(900, xla); } + } + + final private boolean jj_2_902(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_902(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(901, xla); } + } + + final private boolean jj_2_903(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_903(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(902, xla); } + } + + final private boolean jj_2_904(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_904(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(903, xla); } + } + + final private boolean jj_2_905(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_905(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(904, xla); } + } + + final private boolean jj_2_906(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_906(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(905, xla); } + } + + final private boolean jj_2_907(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_907(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(906, xla); } + } + + final private boolean jj_2_908(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_908(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(907, xla); } + } + + final private boolean jj_2_909(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_909(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(908, xla); } + } + + final private boolean jj_2_910(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_910(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(909, xla); } + } + + final private boolean jj_2_911(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_911(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(910, xla); } + } + + final private boolean jj_2_912(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_912(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(911, xla); } + } + + final private boolean jj_2_913(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_913(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(912, xla); } + } + + final private boolean jj_2_914(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_914(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(913, xla); } + } + + final private boolean jj_2_915(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_915(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(914, xla); } + } + + final private boolean jj_2_916(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_916(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(915, xla); } + } + + final private boolean jj_2_917(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_917(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(916, xla); } + } + + final private boolean jj_2_918(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_918(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(917, xla); } + } + + final private boolean jj_2_919(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_919(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(918, xla); } + } + + final private boolean jj_2_920(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_920(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(919, xla); } + } + + final private boolean jj_2_921(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_921(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(920, xla); } + } + + final private boolean jj_2_922(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_922(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(921, xla); } + } + + final private boolean jj_2_923(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_923(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(922, xla); } + } + + final private boolean jj_2_924(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_924(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(923, xla); } + } + + final private boolean jj_2_925(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_925(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(924, xla); } + } + + final private boolean jj_2_926(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_926(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(925, xla); } + } + + final private boolean jj_2_927(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_927(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(926, xla); } + } + + final private boolean jj_2_928(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_928(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(927, xla); } + } + + final private boolean jj_2_929(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_929(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(928, xla); } + } + + final private boolean jj_2_930(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_930(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(929, xla); } + } + + final private boolean jj_2_931(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_931(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(930, xla); } + } + + final private boolean jj_2_932(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_932(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(931, xla); } + } + + final private boolean jj_2_933(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_933(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(932, xla); } + } + + final private boolean jj_2_934(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_934(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(933, xla); } + } + + final private boolean jj_2_935(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_935(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(934, xla); } + } + + final private boolean jj_2_936(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_936(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(935, xla); } + } + + final private boolean jj_2_937(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_937(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(936, xla); } + } + + final private boolean jj_2_938(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_938(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(937, xla); } + } + + final private boolean jj_2_939(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_939(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(938, xla); } + } + + final private boolean jj_2_940(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_940(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(939, xla); } + } + + final private boolean jj_2_941(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_941(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(940, xla); } + } + + final private boolean jj_2_942(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_942(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(941, xla); } + } + + final private boolean jj_2_943(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_943(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(942, xla); } + } + + final private boolean jj_2_944(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_944(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(943, xla); } + } + + final private boolean jj_2_945(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_945(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(944, xla); } + } + + final private boolean jj_2_946(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_946(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(945, xla); } + } + + final private boolean jj_2_947(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_947(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(946, xla); } + } + + final private boolean jj_2_948(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_948(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(947, xla); } + } + + final private boolean jj_2_949(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_949(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(948, xla); } + } + + final private boolean jj_2_950(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_950(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(949, xla); } + } + + final private boolean jj_2_951(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_951(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(950, xla); } + } + + final private boolean jj_2_952(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_952(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(951, xla); } + } + + final private boolean jj_2_953(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_953(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(952, xla); } + } + + final private boolean jj_2_954(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_954(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(953, xla); } + } + + final private boolean jj_2_955(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_955(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(954, xla); } + } + + final private boolean jj_2_956(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_956(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(955, xla); } + } + + final private boolean jj_2_957(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_957(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(956, xla); } + } + + final private boolean jj_2_958(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_958(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(957, xla); } + } + + final private boolean jj_2_959(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_959(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(958, xla); } + } + + final private boolean jj_2_960(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_960(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(959, xla); } + } + + final private boolean jj_2_961(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_961(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(960, xla); } + } + + final private boolean jj_2_962(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_962(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(961, xla); } + } + + final private boolean jj_2_963(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_963(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(962, xla); } + } + + final private boolean jj_2_964(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_964(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(963, xla); } + } + + final private boolean jj_2_965(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_965(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(964, xla); } + } + + final private boolean jj_2_966(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_966(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(965, xla); } + } + + final private boolean jj_2_967(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_967(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(966, xla); } + } + + final private boolean jj_2_968(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_968(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(967, xla); } + } + + final private boolean jj_2_969(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_969(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(968, xla); } + } + + final private boolean jj_2_970(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_970(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(969, xla); } + } + + final private boolean jj_2_971(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_971(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(970, xla); } + } + + final private boolean jj_2_972(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_972(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(971, xla); } + } + + final private boolean jj_2_973(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_973(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(972, xla); } + } + + final private boolean jj_2_974(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_974(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(973, xla); } + } + + final private boolean jj_2_975(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_975(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(974, xla); } + } + + final private boolean jj_2_976(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_976(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(975, xla); } + } + + final private boolean jj_2_977(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_977(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(976, xla); } + } + + final private boolean jj_2_978(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_978(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(977, xla); } + } + + final private boolean jj_2_979(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_979(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(978, xla); } + } + + final private boolean jj_2_980(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_980(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(979, xla); } + } + + final private boolean jj_2_981(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_981(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(980, xla); } + } + + final private boolean jj_2_982(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_982(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(981, xla); } + } + + final private boolean jj_2_983(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_983(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(982, xla); } + } + + final private boolean jj_2_984(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_984(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(983, xla); } + } + + final private boolean jj_2_985(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_985(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(984, xla); } + } + + final private boolean jj_2_986(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_986(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(985, xla); } + } + + final private boolean jj_2_987(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_987(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(986, xla); } + } + + final private boolean jj_2_988(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_988(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(987, xla); } + } + + final private boolean jj_2_989(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_989(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(988, xla); } + } + + final private boolean jj_2_990(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_990(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(989, xla); } + } + + final private boolean jj_2_991(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_991(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(990, xla); } + } + + final private boolean jj_2_992(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_992(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(991, xla); } + } + + final private boolean jj_2_993(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_993(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(992, xla); } + } + + final private boolean jj_2_994(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_994(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(993, xla); } + } + + final private boolean jj_2_995(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_995(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(994, xla); } + } + + final private boolean jj_2_996(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_996(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(995, xla); } + } + + final private boolean jj_2_997(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_997(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(996, xla); } + } + + final private boolean jj_2_998(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_998(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(997, xla); } + } + + final private boolean jj_2_999(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_999(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(998, xla); } + } + + final private boolean jj_2_1000(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1000(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(999, xla); } + } + + final private boolean jj_2_1001(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1001(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1000, xla); } + } + + final private boolean jj_2_1002(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1002(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1001, xla); } + } + + final private boolean jj_2_1003(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1003(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1002, xla); } + } + + final private boolean jj_2_1004(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1004(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1003, xla); } + } + + final private boolean jj_2_1005(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1005(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1004, xla); } + } + + final private boolean jj_2_1006(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1006(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1005, xla); } + } + + final private boolean jj_2_1007(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1007(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1006, xla); } + } + + final private boolean jj_2_1008(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1008(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1007, xla); } + } + + final private boolean jj_2_1009(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1009(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1008, xla); } + } + + final private boolean jj_2_1010(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1010(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1009, xla); } + } + + final private boolean jj_2_1011(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1011(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1010, xla); } + } + + final private boolean jj_2_1012(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1012(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1011, xla); } + } + + final private boolean jj_2_1013(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1013(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1012, xla); } + } + + final private boolean jj_2_1014(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1014(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1013, xla); } + } + + final private boolean jj_2_1015(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1015(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1014, xla); } + } + + final private boolean jj_2_1016(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1016(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1015, xla); } + } + + final private boolean jj_2_1017(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1017(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1016, xla); } + } + + final private boolean jj_2_1018(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1018(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1017, xla); } + } + + final private boolean jj_2_1019(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1019(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1018, xla); } + } + + final private boolean jj_2_1020(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1020(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1019, xla); } + } + + final private boolean jj_2_1021(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1021(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1020, xla); } + } + + final private boolean jj_2_1022(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1022(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1021, xla); } + } + + final private boolean jj_2_1023(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1023(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1022, xla); } + } + + final private boolean jj_2_1024(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1024(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1023, xla); } + } + + final private boolean jj_2_1025(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1025(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1024, xla); } + } + + final private boolean jj_2_1026(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1026(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1025, xla); } + } + + final private boolean jj_2_1027(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1027(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1026, xla); } + } + + final private boolean jj_2_1028(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1028(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1027, xla); } + } + + final private boolean jj_2_1029(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1029(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1028, xla); } + } + + final private boolean jj_2_1030(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1030(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1029, xla); } + } + + final private boolean jj_2_1031(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1031(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1030, xla); } + } + + final private boolean jj_2_1032(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1032(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1031, xla); } + } + + final private boolean jj_2_1033(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1033(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1032, xla); } + } + + final private boolean jj_2_1034(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1034(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1033, xla); } + } + + final private boolean jj_2_1035(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1035(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1034, xla); } + } + + final private boolean jj_2_1036(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1036(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1035, xla); } + } + + final private boolean jj_2_1037(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1037(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1036, xla); } + } + + final private boolean jj_2_1038(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1038(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1037, xla); } + } + + final private boolean jj_2_1039(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1039(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1038, xla); } + } + + final private boolean jj_2_1040(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1040(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1039, xla); } + } + + final private boolean jj_2_1041(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1041(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1040, xla); } + } + + final private boolean jj_2_1042(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1042(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1041, xla); } + } + + final private boolean jj_2_1043(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1043(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1042, xla); } + } + + final private boolean jj_2_1044(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1044(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1043, xla); } + } + + final private boolean jj_2_1045(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1045(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1044, xla); } + } + + final private boolean jj_2_1046(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1046(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1045, xla); } + } + + final private boolean jj_2_1047(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1047(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1046, xla); } + } + + final private boolean jj_2_1048(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1048(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1047, xla); } + } + + final private boolean jj_2_1049(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1049(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1048, xla); } + } + + final private boolean jj_2_1050(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1050(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1049, xla); } + } + + final private boolean jj_2_1051(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1051(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1050, xla); } + } + + final private boolean jj_2_1052(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1052(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1051, xla); } + } + + final private boolean jj_2_1053(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1053(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1052, xla); } + } + + final private boolean jj_2_1054(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1054(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1053, xla); } + } + + final private boolean jj_2_1055(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1055(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1054, xla); } + } + + final private boolean jj_2_1056(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1056(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1055, xla); } + } + + final private boolean jj_2_1057(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1057(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1056, xla); } + } + + final private boolean jj_2_1058(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1058(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1057, xla); } + } + + final private boolean jj_2_1059(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1059(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1058, xla); } + } + + final private boolean jj_2_1060(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1060(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1059, xla); } + } + + final private boolean jj_2_1061(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1061(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1060, xla); } + } + + final private boolean jj_2_1062(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1062(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1061, xla); } + } + + final private boolean jj_2_1063(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1063(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1062, xla); } + } + + final private boolean jj_2_1064(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1064(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1063, xla); } + } + + final private boolean jj_2_1065(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1065(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1064, xla); } + } + + final private boolean jj_2_1066(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1066(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1065, xla); } + } + + final private boolean jj_2_1067(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1067(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1066, xla); } + } + + final private boolean jj_2_1068(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1068(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1067, xla); } + } + + final private boolean jj_2_1069(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1069(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1068, xla); } + } + + final private boolean jj_2_1070(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1070(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1069, xla); } + } + + final private boolean jj_2_1071(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1071(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1070, xla); } + } + + final private boolean jj_2_1072(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1072(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1071, xla); } + } + + final private boolean jj_2_1073(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1073(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1072, xla); } + } + + final private boolean jj_2_1074(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1074(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1073, xla); } + } + + final private boolean jj_2_1075(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1075(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1074, xla); } + } + + final private boolean jj_2_1076(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1076(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1075, xla); } + } + + final private boolean jj_2_1077(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1077(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1076, xla); } + } + + final private boolean jj_2_1078(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1078(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1077, xla); } + } + + final private boolean jj_2_1079(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1079(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1078, xla); } + } + + final private boolean jj_2_1080(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1080(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1079, xla); } + } + + final private boolean jj_2_1081(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1081(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1080, xla); } + } + + final private boolean jj_2_1082(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1082(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1081, xla); } + } + + final private boolean jj_2_1083(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1083(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1082, xla); } + } + + final private boolean jj_2_1084(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1084(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1083, xla); } + } + + final private boolean jj_2_1085(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1085(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1084, xla); } + } + + final private boolean jj_2_1086(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1086(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1085, xla); } + } + + final private boolean jj_2_1087(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1087(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1086, xla); } + } + + final private boolean jj_2_1088(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1088(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1087, xla); } + } + + final private boolean jj_2_1089(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1089(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1088, xla); } + } + + final private boolean jj_2_1090(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1090(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1089, xla); } + } + + final private boolean jj_2_1091(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1091(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1090, xla); } + } + + final private boolean jj_2_1092(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1092(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1091, xla); } + } + + final private boolean jj_2_1093(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1093(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1092, xla); } + } + + final private boolean jj_2_1094(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1094(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1093, xla); } + } + + final private boolean jj_2_1095(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1095(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1094, xla); } + } + + final private boolean jj_2_1096(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1096(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1095, xla); } + } + + final private boolean jj_2_1097(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1097(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1096, xla); } + } + + final private boolean jj_2_1098(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1098(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1097, xla); } + } + + final private boolean jj_2_1099(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1099(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1098, xla); } + } + + final private boolean jj_2_1100(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1100(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1099, xla); } + } + + final private boolean jj_2_1101(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1101(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1100, xla); } + } + + final private boolean jj_2_1102(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1102(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1101, xla); } + } + + final private boolean jj_2_1103(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1103(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1102, xla); } + } + + final private boolean jj_2_1104(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1104(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1103, xla); } + } + + final private boolean jj_2_1105(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1105(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1104, xla); } + } + + final private boolean jj_2_1106(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1106(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1105, xla); } + } + + final private boolean jj_2_1107(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1107(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1106, xla); } + } + + final private boolean jj_2_1108(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1108(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1107, xla); } + } + + final private boolean jj_2_1109(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1109(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1108, xla); } + } + + final private boolean jj_2_1110(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1110(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1109, xla); } + } + + final private boolean jj_2_1111(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1111(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1110, xla); } + } + + final private boolean jj_2_1112(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1112(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1111, xla); } + } + + final private boolean jj_2_1113(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1113(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1112, xla); } + } + + final private boolean jj_2_1114(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1114(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1113, xla); } + } + + final private boolean jj_2_1115(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1115(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1114, xla); } + } + + final private boolean jj_2_1116(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1116(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1115, xla); } + } + + final private boolean jj_2_1117(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1117(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1116, xla); } + } + + final private boolean jj_2_1118(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1118(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1117, xla); } + } + + final private boolean jj_2_1119(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1119(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1118, xla); } + } + + final private boolean jj_2_1120(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1120(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1119, xla); } + } + + final private boolean jj_2_1121(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1121(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1120, xla); } + } + + final private boolean jj_2_1122(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1122(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1121, xla); } + } + + final private boolean jj_2_1123(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1123(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1122, xla); } + } + + final private boolean jj_2_1124(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1124(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1123, xla); } + } + + final private boolean jj_2_1125(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1125(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1124, xla); } + } + + final private boolean jj_2_1126(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1126(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1125, xla); } + } + + final private boolean jj_2_1127(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1127(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1126, xla); } + } + + final private boolean jj_2_1128(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1128(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1127, xla); } + } + + final private boolean jj_2_1129(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1129(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1128, xla); } + } + + final private boolean jj_2_1130(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1130(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1129, xla); } + } + + final private boolean jj_2_1131(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1131(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1130, xla); } + } + + final private boolean jj_2_1132(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1132(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1131, xla); } + } + + final private boolean jj_2_1133(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1133(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1132, xla); } + } + + final private boolean jj_2_1134(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1134(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1133, xla); } + } + + final private boolean jj_2_1135(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1135(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1134, xla); } + } + + final private boolean jj_2_1136(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1136(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1135, xla); } + } + + final private boolean jj_2_1137(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1137(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1136, xla); } + } + + final private boolean jj_2_1138(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1138(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1137, xla); } + } + + final private boolean jj_2_1139(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1139(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1138, xla); } + } + + final private boolean jj_2_1140(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1140(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1139, xla); } + } + + final private boolean jj_2_1141(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1141(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1140, xla); } + } + + final private boolean jj_2_1142(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1142(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1141, xla); } + } + + final private boolean jj_2_1143(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1143(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1142, xla); } + } + + final private boolean jj_2_1144(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1144(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1143, xla); } + } + + final private boolean jj_2_1145(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1145(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1144, xla); } + } + + final private boolean jj_2_1146(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1146(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1145, xla); } + } + + final private boolean jj_2_1147(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1147(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1146, xla); } + } + + final private boolean jj_2_1148(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1148(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1147, xla); } + } + + final private boolean jj_2_1149(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1149(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1148, xla); } + } + + final private boolean jj_2_1150(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1150(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1149, xla); } + } + + final private boolean jj_2_1151(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1151(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1150, xla); } + } + + final private boolean jj_2_1152(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1152(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1151, xla); } + } + + final private boolean jj_2_1153(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1153(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1152, xla); } + } + + final private boolean jj_2_1154(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1154(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1153, xla); } + } + + final private boolean jj_2_1155(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1155(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1154, xla); } + } + + final private boolean jj_2_1156(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1156(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1155, xla); } + } + + final private boolean jj_2_1157(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1157(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1156, xla); } + } + + final private boolean jj_2_1158(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1158(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1157, xla); } + } + + final private boolean jj_2_1159(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1159(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1158, xla); } + } + + final private boolean jj_2_1160(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1160(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1159, xla); } + } + + final private boolean jj_2_1161(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1161(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1160, xla); } + } + + final private boolean jj_2_1162(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1162(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1161, xla); } + } + + final private boolean jj_2_1163(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1163(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1162, xla); } + } + + final private boolean jj_2_1164(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1164(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1163, xla); } + } + + final private boolean jj_2_1165(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1165(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1164, xla); } + } + + final private boolean jj_2_1166(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1166(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1165, xla); } + } + + final private boolean jj_2_1167(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1167(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1166, xla); } + } + + final private boolean jj_2_1168(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1168(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1167, xla); } + } + + final private boolean jj_2_1169(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1169(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1168, xla); } + } + + final private boolean jj_2_1170(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1170(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1169, xla); } + } + + final private boolean jj_2_1171(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1171(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1170, xla); } + } + + final private boolean jj_2_1172(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1172(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1171, xla); } + } + + final private boolean jj_2_1173(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1173(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1172, xla); } + } + + final private boolean jj_2_1174(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1174(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1173, xla); } + } + + final private boolean jj_2_1175(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1175(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1174, xla); } + } + + final private boolean jj_2_1176(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1176(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1175, xla); } + } + + final private boolean jj_2_1177(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1177(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1176, xla); } + } + + final private boolean jj_2_1178(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1178(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1177, xla); } + } + + final private boolean jj_2_1179(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1179(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1178, xla); } + } + + final private boolean jj_2_1180(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1180(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1179, xla); } + } + + final private boolean jj_2_1181(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1181(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1180, xla); } + } + + final private boolean jj_2_1182(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1182(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1181, xla); } + } + + final private boolean jj_2_1183(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1183(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1182, xla); } + } + + final private boolean jj_2_1184(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1184(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1183, xla); } + } + + final private boolean jj_2_1185(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1185(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1184, xla); } + } + + final private boolean jj_2_1186(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1186(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1185, xla); } + } + + final private boolean jj_2_1187(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1187(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1186, xla); } + } + + final private boolean jj_2_1188(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1188(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1187, xla); } + } + + final private boolean jj_2_1189(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1189(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1188, xla); } + } + + final private boolean jj_2_1190(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1190(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1189, xla); } + } + + final private boolean jj_2_1191(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1191(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1190, xla); } + } + + final private boolean jj_2_1192(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1192(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1191, xla); } + } + + final private boolean jj_2_1193(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1193(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1192, xla); } + } + + final private boolean jj_2_1194(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1194(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1193, xla); } + } + + final private boolean jj_2_1195(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1195(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1194, xla); } + } + + final private boolean jj_2_1196(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1196(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1195, xla); } + } + + final private boolean jj_2_1197(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1197(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1196, xla); } + } + + final private boolean jj_2_1198(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1198(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1197, xla); } + } + + final private boolean jj_2_1199(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1199(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1198, xla); } + } + + final private boolean jj_2_1200(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1200(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1199, xla); } + } + + final private boolean jj_2_1201(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1201(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1200, xla); } + } + + final private boolean jj_2_1202(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1202(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1201, xla); } + } + + final private boolean jj_2_1203(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1203(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1202, xla); } + } + + final private boolean jj_2_1204(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1204(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1203, xla); } + } + + final private boolean jj_2_1205(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1205(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1204, xla); } + } + + final private boolean jj_2_1206(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1206(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1205, xla); } + } + + final private boolean jj_2_1207(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1207(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1206, xla); } + } + + final private boolean jj_2_1208(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1208(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1207, xla); } + } + + final private boolean jj_2_1209(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1209(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1208, xla); } + } + + final private boolean jj_2_1210(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1210(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1209, xla); } + } + + final private boolean jj_2_1211(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1211(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1210, xla); } + } + + final private boolean jj_2_1212(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1212(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1211, xla); } + } + + final private boolean jj_2_1213(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1213(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1212, xla); } + } + + final private boolean jj_2_1214(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1214(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1213, xla); } + } + + final private boolean jj_2_1215(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1215(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1214, xla); } + } + + final private boolean jj_2_1216(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1216(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1215, xla); } + } + + final private boolean jj_2_1217(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1217(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1216, xla); } + } + + final private boolean jj_2_1218(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1218(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1217, xla); } + } + + final private boolean jj_2_1219(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1219(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1218, xla); } + } + + final private boolean jj_2_1220(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1220(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1219, xla); } + } + + final private boolean jj_2_1221(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1221(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1220, xla); } + } + + final private boolean jj_2_1222(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1222(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1221, xla); } + } + + final private boolean jj_2_1223(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1223(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1222, xla); } + } + + final private boolean jj_2_1224(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1224(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1223, xla); } + } + + final private boolean jj_2_1225(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1225(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1224, xla); } + } + + final private boolean jj_2_1226(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1226(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1225, xla); } + } + + final private boolean jj_2_1227(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1227(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1226, xla); } + } + + final private boolean jj_2_1228(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1228(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1227, xla); } + } + + final private boolean jj_2_1229(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1229(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1228, xla); } + } + + final private boolean jj_2_1230(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1230(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1229, xla); } + } + + final private boolean jj_2_1231(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1231(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1230, xla); } + } + + final private boolean jj_2_1232(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1232(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1231, xla); } + } + + final private boolean jj_2_1233(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1233(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1232, xla); } + } + + final private boolean jj_2_1234(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1234(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1233, xla); } + } + + final private boolean jj_2_1235(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1235(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1234, xla); } + } + + final private boolean jj_2_1236(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1236(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1235, xla); } + } + + final private boolean jj_2_1237(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1237(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1236, xla); } + } + + final private boolean jj_2_1238(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1238(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1237, xla); } + } + + final private boolean jj_2_1239(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1239(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1238, xla); } + } + + final private boolean jj_2_1240(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1240(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1239, xla); } + } + + final private boolean jj_2_1241(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1241(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1240, xla); } + } + + final private boolean jj_2_1242(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1242(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1241, xla); } + } + + final private boolean jj_2_1243(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1243(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1242, xla); } + } + + final private boolean jj_2_1244(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1244(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1243, xla); } + } + + final private boolean jj_2_1245(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1245(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1244, xla); } + } + + final private boolean jj_2_1246(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1246(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1245, xla); } + } + + final private boolean jj_2_1247(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1247(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1246, xla); } + } + + final private boolean jj_2_1248(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1248(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1247, xla); } + } + + final private boolean jj_2_1249(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1249(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1248, xla); } + } + + final private boolean jj_2_1250(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1250(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1249, xla); } + } + + final private boolean jj_2_1251(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1251(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1250, xla); } + } + + final private boolean jj_2_1252(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1252(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1251, xla); } + } + + final private boolean jj_2_1253(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1253(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1252, xla); } + } + + final private boolean jj_2_1254(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1254(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1253, xla); } + } + + final private boolean jj_2_1255(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1255(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1254, xla); } + } + + final private boolean jj_2_1256(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1256(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1255, xla); } + } + + final private boolean jj_2_1257(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1257(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1256, xla); } + } + + final private boolean jj_2_1258(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1258(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1257, xla); } + } + + final private boolean jj_2_1259(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1259(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1258, xla); } + } + + final private boolean jj_2_1260(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1260(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1259, xla); } + } + + final private boolean jj_2_1261(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1261(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1260, xla); } + } + + final private boolean jj_2_1262(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1262(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1261, xla); } + } + + final private boolean jj_2_1263(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1263(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1262, xla); } + } + + final private boolean jj_2_1264(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1264(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1263, xla); } + } + + final private boolean jj_2_1265(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1265(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1264, xla); } + } + + final private boolean jj_2_1266(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1266(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1265, xla); } + } + + final private boolean jj_2_1267(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1267(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1266, xla); } + } + + final private boolean jj_2_1268(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1268(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1267, xla); } + } + + final private boolean jj_2_1269(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1269(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1268, xla); } + } + + final private boolean jj_2_1270(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1270(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1269, xla); } + } + + final private boolean jj_2_1271(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1271(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1270, xla); } + } + + final private boolean jj_2_1272(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1272(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1271, xla); } + } + + final private boolean jj_2_1273(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1273(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1272, xla); } + } + + final private boolean jj_2_1274(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1274(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1273, xla); } + } + + final private boolean jj_2_1275(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1275(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1274, xla); } + } + + final private boolean jj_2_1276(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1276(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1275, xla); } + } + + final private boolean jj_2_1277(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1277(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1276, xla); } + } + + final private boolean jj_2_1278(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1278(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1277, xla); } + } + + final private boolean jj_2_1279(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1279(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1278, xla); } + } + + final private boolean jj_2_1280(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1280(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1279, xla); } + } + + final private boolean jj_2_1281(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1281(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1280, xla); } + } + + final private boolean jj_2_1282(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1282(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1281, xla); } + } + + final private boolean jj_2_1283(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1283(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1282, xla); } + } + + final private boolean jj_2_1284(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1284(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1283, xla); } + } + + final private boolean jj_2_1285(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1285(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1284, xla); } + } + + final private boolean jj_2_1286(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1286(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1285, xla); } + } + + final private boolean jj_2_1287(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1287(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1286, xla); } + } + + final private boolean jj_2_1288(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1288(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1287, xla); } + } + + final private boolean jj_2_1289(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1289(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1288, xla); } + } + + final private boolean jj_2_1290(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1290(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1289, xla); } + } + + final private boolean jj_2_1291(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1291(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1290, xla); } + } + + final private boolean jj_2_1292(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1292(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1291, xla); } + } + + final private boolean jj_2_1293(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1293(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1292, xla); } + } + + final private boolean jj_2_1294(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1294(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1293, xla); } + } + + final private boolean jj_2_1295(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1295(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1294, xla); } + } + + final private boolean jj_2_1296(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1296(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1295, xla); } + } + + final private boolean jj_2_1297(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1297(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1296, xla); } + } + + final private boolean jj_2_1298(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1298(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1297, xla); } + } + + final private boolean jj_2_1299(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1299(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1298, xla); } + } + + final private boolean jj_2_1300(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1300(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1299, xla); } + } + + final private boolean jj_2_1301(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1301(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1300, xla); } + } + + final private boolean jj_2_1302(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1302(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1301, xla); } + } + + final private boolean jj_2_1303(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1303(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1302, xla); } + } + + final private boolean jj_2_1304(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1304(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1303, xla); } + } + + final private boolean jj_2_1305(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1305(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1304, xla); } + } + + final private boolean jj_2_1306(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1306(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1305, xla); } + } + + final private boolean jj_2_1307(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1307(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1306, xla); } + } + + final private boolean jj_2_1308(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1308(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1307, xla); } + } + + final private boolean jj_2_1309(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1309(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1308, xla); } + } + + final private boolean jj_2_1310(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1310(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1309, xla); } + } + + final private boolean jj_2_1311(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1311(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1310, xla); } + } + + final private boolean jj_2_1312(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1312(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1311, xla); } + } + + final private boolean jj_2_1313(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1313(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1312, xla); } + } + + final private boolean jj_2_1314(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1314(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1313, xla); } + } + + final private boolean jj_2_1315(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1315(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1314, xla); } + } + + final private boolean jj_2_1316(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1316(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1315, xla); } + } + + final private boolean jj_2_1317(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1317(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1316, xla); } + } + + final private boolean jj_2_1318(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1318(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1317, xla); } + } + + final private boolean jj_2_1319(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1319(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1318, xla); } + } + + final private boolean jj_2_1320(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1320(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1319, xla); } + } + + final private boolean jj_2_1321(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1321(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1320, xla); } + } + + final private boolean jj_2_1322(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1322(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1321, xla); } + } + + final private boolean jj_2_1323(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1323(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1322, xla); } + } + + final private boolean jj_2_1324(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1324(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1323, xla); } + } + + final private boolean jj_2_1325(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1325(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1324, xla); } + } + + final private boolean jj_2_1326(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1326(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1325, xla); } + } + + final private boolean jj_2_1327(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1327(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1326, xla); } + } + + final private boolean jj_2_1328(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1328(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1327, xla); } + } + + final private boolean jj_2_1329(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1329(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1328, xla); } + } + + final private boolean jj_2_1330(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1330(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1329, xla); } + } + + final private boolean jj_2_1331(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1331(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1330, xla); } + } + + final private boolean jj_2_1332(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1332(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1331, xla); } + } + + final private boolean jj_2_1333(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1333(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1332, xla); } + } + + final private boolean jj_2_1334(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1334(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1333, xla); } + } + + final private boolean jj_2_1335(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1335(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1334, xla); } + } + + final private boolean jj_2_1336(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1336(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1335, xla); } + } + + final private boolean jj_2_1337(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1337(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1336, xla); } + } + + final private boolean jj_2_1338(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1338(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1337, xla); } + } + + final private boolean jj_2_1339(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1339(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1338, xla); } + } + + final private boolean jj_2_1340(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1340(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1339, xla); } + } + + final private boolean jj_2_1341(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1341(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1340, xla); } + } + + final private boolean jj_2_1342(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1342(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1341, xla); } + } + + final private boolean jj_2_1343(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1343(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1342, xla); } + } + + final private boolean jj_2_1344(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1344(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1343, xla); } + } + + final private boolean jj_2_1345(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1345(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1344, xla); } + } + + final private boolean jj_2_1346(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1346(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1345, xla); } + } + + final private boolean jj_2_1347(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1347(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1346, xla); } + } + + final private boolean jj_2_1348(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1348(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1347, xla); } + } + + final private boolean jj_2_1349(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1349(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1348, xla); } + } + + final private boolean jj_2_1350(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1350(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1349, xla); } + } + + final private boolean jj_2_1351(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1351(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1350, xla); } + } + + final private boolean jj_2_1352(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1352(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1351, xla); } + } + + final private boolean jj_2_1353(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1353(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1352, xla); } + } + + final private boolean jj_2_1354(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1354(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1353, xla); } + } + + final private boolean jj_2_1355(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1355(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1354, xla); } + } + + final private boolean jj_2_1356(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1356(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1355, xla); } + } + + final private boolean jj_2_1357(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1357(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1356, xla); } + } + + final private boolean jj_2_1358(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1358(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1357, xla); } + } + + final private boolean jj_2_1359(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1359(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1358, xla); } + } + + final private boolean jj_2_1360(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1360(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1359, xla); } + } + + final private boolean jj_2_1361(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1361(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1360, xla); } + } + + final private boolean jj_2_1362(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1362(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1361, xla); } + } + + final private boolean jj_2_1363(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1363(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1362, xla); } + } + + final private boolean jj_2_1364(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1364(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1363, xla); } + } + + final private boolean jj_2_1365(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1365(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1364, xla); } + } + + final private boolean jj_2_1366(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1366(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1365, xla); } + } + + final private boolean jj_2_1367(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1367(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1366, xla); } + } + + final private boolean jj_2_1368(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1368(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1367, xla); } + } + + final private boolean jj_2_1369(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1369(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1368, xla); } + } + + final private boolean jj_2_1370(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1370(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1369, xla); } + } + + final private boolean jj_2_1371(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1371(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1370, xla); } + } + + final private boolean jj_2_1372(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1372(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1371, xla); } + } + + final private boolean jj_2_1373(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1373(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1372, xla); } + } + + final private boolean jj_2_1374(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1374(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1373, xla); } + } + + final private boolean jj_2_1375(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1375(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1374, xla); } + } + + final private boolean jj_2_1376(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1376(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1375, xla); } + } + + final private boolean jj_2_1377(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1377(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1376, xla); } + } + + final private boolean jj_2_1378(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1378(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1377, xla); } + } + + final private boolean jj_2_1379(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1379(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1378, xla); } + } + + final private boolean jj_2_1380(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1380(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1379, xla); } + } + + final private boolean jj_2_1381(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1381(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1380, xla); } + } + + final private boolean jj_2_1382(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1382(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1381, xla); } + } + + final private boolean jj_2_1383(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1383(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1382, xla); } + } + + final private boolean jj_2_1384(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1384(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1383, xla); } + } + + final private boolean jj_2_1385(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1385(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1384, xla); } + } + + final private boolean jj_2_1386(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1386(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1385, xla); } + } + + final private boolean jj_2_1387(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1387(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1386, xla); } + } + + final private boolean jj_2_1388(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1388(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1387, xla); } + } + + final private boolean jj_2_1389(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1389(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1388, xla); } + } + + final private boolean jj_2_1390(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1390(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1389, xla); } + } + + final private boolean jj_2_1391(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1391(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1390, xla); } + } + + final private boolean jj_2_1392(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1392(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1391, xla); } + } + + final private boolean jj_2_1393(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1393(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1392, xla); } + } + + final private boolean jj_2_1394(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1394(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1393, xla); } + } + + final private boolean jj_2_1395(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1395(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1394, xla); } + } + + final private boolean jj_2_1396(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1396(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1395, xla); } + } + + final private boolean jj_2_1397(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1397(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1396, xla); } + } + + final private boolean jj_2_1398(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1398(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1397, xla); } + } + + final private boolean jj_2_1399(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1399(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1398, xla); } + } + + final private boolean jj_2_1400(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1400(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1399, xla); } + } + + final private boolean jj_2_1401(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1401(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1400, xla); } + } + + final private boolean jj_3R_313() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_140() { + return false; + } + + final private boolean jj_3_238() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_235() { + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_237() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_235()) { + jj_scanpos = xsp; + if (jj_3R_140()) return true; + } + if (jj_3R_139()) return true; + return false; + } + + final private boolean jj_3_685() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_684() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_236() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(ROW)) return true; + if (jj_3R_139()) return true; + return false; + } + + final private boolean jj_3R_138() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_236()) { + jj_scanpos = xsp; + if (jj_3_237()) { + jj_scanpos = xsp; + if (jj_3_238()) return true; + } + } + return false; + } + + final private boolean jj_3_683() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_682() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_234() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_138()) return true; + return false; + } + + final private boolean jj_3_681() { + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_680() { + if (jj_scan_token(MULTISET)) return true; + return false; + } + + final private boolean jj_3R_271() { + if (jj_3R_138()) return true; + return false; + } + + final private boolean jj_3R_217() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_680()) { + jj_scanpos = xsp; + if (jj_3_681()) return true; + } + return false; + } + + final private boolean jj_3R_59() { + if (jj_scan_token(VALUES)) return true; + if (jj_3R_271()) return true; + return false; + } + + final private boolean jj_3_647() { + if (jj_scan_token(DOUBLE)) return true; + return false; + } + + final private boolean jj_3_649() { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + final private boolean jj_3_641() { + if (jj_scan_token(SMALLINT)) return true; + return false; + } + + final private boolean jj_3_637() { + if (jj_scan_token(VARBINARY)) return true; + return false; + } + + final private boolean jj_3_643() { + if (jj_scan_token(BIGINT)) return true; + return false; + } + + final private boolean jj_3_679() { + if (jj_scan_token(SQL_INTERVAL_SECOND)) return true; + return false; + } + + final private boolean jj_3_639() { + if (jj_scan_token(TINYINT)) return true; + return false; + } + + final private boolean jj_3_678() { + if (jj_scan_token(SQL_INTERVAL_MINUTE_TO_SECOND)) return true; + return false; + } + + final private boolean jj_3_645() { + if (jj_scan_token(REAL)) return true; + return false; + } + + final private boolean jj_3_677() { + if (jj_scan_token(SQL_INTERVAL_MINUTE)) return true; + return false; + } + + final private boolean jj_3_676() { + if (jj_scan_token(SQL_INTERVAL_HOUR_TO_SECOND)) return true; + return false; + } + + final private boolean jj_3_633() { + if (jj_scan_token(INTEGER)) return true; + return false; + } + + final private boolean jj_3_635() { + if (jj_scan_token(BINARY)) return true; + return false; + } + + final private boolean jj_3_675() { + if (jj_scan_token(SQL_INTERVAL_HOUR_TO_MINUTE)) return true; + return false; + } + + final private boolean jj_3_631() { + if (jj_scan_token(BOOLEAN)) return true; + return false; + } + + final private boolean jj_3_674() { + if (jj_scan_token(SQL_INTERVAL_HOUR)) return true; + return false; + } + + final private boolean jj_3R_60() { + if (jj_scan_token(TABLE)) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_625() { + if (jj_scan_token(TIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_629() { + if (jj_scan_token(NUMERIC)) return true; + return false; + } + + final private boolean jj_3_673() { + if (jj_scan_token(SQL_INTERVAL_DAY_TO_SECOND)) return true; + return false; + } + + final private boolean jj_3_627() { + if (jj_scan_token(DECIMAL)) return true; + return false; + } + + final private boolean jj_3_672() { + if (jj_scan_token(SQL_INTERVAL_DAY_TO_MINUTE)) return true; + return false; + } + + final private boolean jj_3_671() { + if (jj_scan_token(SQL_INTERVAL_DAY_TO_HOUR)) return true; + return false; + } + + final private boolean jj_3_670() { + if (jj_scan_token(SQL_INTERVAL_DAY)) return true; + return false; + } + + final private boolean jj_3_669() { + if (jj_scan_token(SQL_INTERVAL_MONTH)) return true; + return false; + } + + final private boolean jj_3_619() { + if (jj_scan_token(VARCHAR)) return true; + return false; + } + + final private boolean jj_3_668() { + if (jj_scan_token(SQL_INTERVAL_YEAR_TO_MONTH)) return true; + return false; + } + + final private boolean jj_3_623() { + if (jj_scan_token(TIME)) return true; + return false; + } + + final private boolean jj_3_648() { + if (jj_scan_token(SQL_FLOAT)) return true; + return false; + } + + final private boolean jj_3_667() { + if (jj_scan_token(SQL_INTERVAL_YEAR)) return true; + return false; + } + + final private boolean jj_3_621() { + if (jj_scan_token(DATE)) return true; + return false; + } + + final private boolean jj_3_646() { + if (jj_scan_token(SQL_DOUBLE)) return true; + return false; + } + + final private boolean jj_3_666() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_648()) { + jj_scanpos = xsp; + if (jj_3_649()) return true; + } + return false; + } + + final private boolean jj_3_644() { + if (jj_scan_token(SQL_REAL)) return true; + return false; + } + + final private boolean jj_3_665() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_646()) { + jj_scanpos = xsp; + if (jj_3_647()) return true; + } + return false; + } + + final private boolean jj_3_617() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + final private boolean jj_3_642() { + if (jj_scan_token(SQL_BIGINT)) return true; + return false; + } + + final private boolean jj_3_664() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_644()) { + jj_scanpos = xsp; + if (jj_3_645()) return true; + } + return false; + } + + final private boolean jj_3_640() { + if (jj_scan_token(SQL_SMALLINT)) return true; + return false; + } + + final private boolean jj_3_663() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_642()) { + jj_scanpos = xsp; + if (jj_3_643()) return true; + } + return false; + } + + final private boolean jj_3_638() { + if (jj_scan_token(SQL_TINYINT)) return true; + return false; + } + + final private boolean jj_3_662() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_640()) { + jj_scanpos = xsp; + if (jj_3_641()) return true; + } + return false; + } + + final private boolean jj_3_636() { + if (jj_scan_token(SQL_VARBINARY)) return true; + return false; + } + + final private boolean jj_3_661() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_638()) { + jj_scanpos = xsp; + if (jj_3_639()) return true; + } + return false; + } + + final private boolean jj_3_634() { + if (jj_scan_token(SQL_BINARY)) return true; + return false; + } + + final private boolean jj_3_660() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_636()) { + jj_scanpos = xsp; + if (jj_3_637()) return true; + } + return false; + } + + final private boolean jj_3_632() { + if (jj_scan_token(SQL_INTEGER)) return true; + return false; + } + + final private boolean jj_3_659() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_634()) { + jj_scanpos = xsp; + if (jj_3_635()) return true; + } + return false; + } + + final private boolean jj_3_630() { + if (jj_scan_token(SQL_BOOLEAN)) return true; + return false; + } + + final private boolean jj_3_658() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_632()) { + jj_scanpos = xsp; + if (jj_3_633()) return true; + } + return false; + } + + final private boolean jj_3_628() { + if (jj_scan_token(SQL_NUMERIC)) return true; + return false; + } + + final private boolean jj_3_657() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_630()) { + jj_scanpos = xsp; + if (jj_3_631()) return true; + } + return false; + } + + final private boolean jj_3_626() { + if (jj_scan_token(SQL_DECIMAL)) return true; + return false; + } + + final private boolean jj_3_656() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_628()) { + jj_scanpos = xsp; + if (jj_3_629()) return true; + } + return false; + } + + final private boolean jj_3_624() { + if (jj_scan_token(SQL_TIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_655() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_626()) { + jj_scanpos = xsp; + if (jj_3_627()) return true; + } + return false; + } + + final private boolean jj_3_622() { + if (jj_scan_token(SQL_TIME)) return true; + return false; + } + + final private boolean jj_3_654() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_624()) { + jj_scanpos = xsp; + if (jj_3_625()) return true; + } + return false; + } + + final private boolean jj_3_620() { + if (jj_scan_token(SQL_DATE)) return true; + return false; + } + + final private boolean jj_3_653() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_622()) { + jj_scanpos = xsp; + if (jj_3_623()) return true; + } + return false; + } + + final private boolean jj_3_611() { + if (jj_scan_token(NUMERIC)) return true; + return false; + } + + final private boolean jj_3_618() { + if (jj_scan_token(SQL_VARCHAR)) return true; + return false; + } + + final private boolean jj_3_652() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_620()) { + jj_scanpos = xsp; + if (jj_3_621()) return true; + } + return false; + } + + final private boolean jj_3_616() { + if (jj_scan_token(SQL_CHAR)) return true; + return false; + } + + final private boolean jj_3_651() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_618()) { + jj_scanpos = xsp; + if (jj_3_619()) return true; + } + return false; + } + + final private boolean jj_3_650() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_616()) { + jj_scanpos = xsp; + if (jj_3_617()) return true; + } + return false; + } + + final private boolean jj_3_610() { + if (jj_scan_token(DEC)) return true; + return false; + } + + final private boolean jj_3_614() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_233() { + if (jj_scan_token(SPECIFIC)) return true; + return false; + } + + final private boolean jj_3_615() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_613() { + if (jj_scan_token(ANY)) return true; + return false; + } + + final private boolean jj_3_609() { + if (jj_scan_token(DECIMAL)) return true; + return false; + } + + final private boolean jj_3_612() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_609()) { + jj_scanpos = xsp; + if (jj_3_610()) { + jj_scanpos = xsp; + if (jj_3_611()) return true; + } + } + return false; + } + + final private boolean jj_3R_222() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_612()) { + jj_scanpos = xsp; + if (jj_3_613()) return true; + } + xsp = jj_scanpos; + if (jj_3_615()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_231() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3R_225() { + return false; + } + + final private boolean jj_3_232() { + if (jj_3R_91()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_231()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_608() { + if (jj_scan_token(VARBINARY)) return true; + return false; + } + + final private boolean jj_3_606() { + if (jj_scan_token(VARYING)) return true; + return false; + } + + final private boolean jj_3R_216() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_607() { + if (jj_scan_token(BINARY)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_606()) { + jj_scanpos = xsp; + if (jj_3R_225()) return true; + } + return false; + } + + final private boolean jj_3R_221() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_607()) { + jj_scanpos = xsp; + if (jj_3_608()) return true; + } + if (jj_3R_209()) return true; + return false; + } + + final private boolean jj_3_595() { + if (jj_scan_token(INT)) return true; + return false; + } + + final private boolean jj_3_230() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_596() { + if (jj_scan_token(PRECISION)) return true; + return false; + } + + final private boolean jj_3_605() { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + final private boolean jj_3_604() { + if (jj_scan_token(DOUBLE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_596()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_603() { + if (jj_scan_token(REAL)) return true; + return false; + } + + final private boolean jj_3R_137() { + if (jj_3R_116()) return true; + if (jj_3R_91()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_230()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_602() { + if (jj_scan_token(BIGINT)) return true; + return false; + } + + final private boolean jj_3_601() { + if (jj_scan_token(SMALLINT)) return true; + return false; + } + + final private boolean jj_3_594() { + if (jj_scan_token(INTEGER)) return true; + return false; + } + + final private boolean jj_3_600() { + if (jj_scan_token(TINYINT)) return true; + return false; + } + + final private boolean jj_3_599() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_594()) { + jj_scanpos = xsp; + if (jj_3_595()) return true; + } + return false; + } + + final private boolean jj_3_598() { + if (jj_scan_token(BOOLEAN)) return true; + return false; + } + + final private boolean jj_3_229() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_137()) return true; + return false; + } + + final private boolean jj_3_597() { + if (jj_scan_token(GEOMETRY)) return true; + return false; + } + + final private boolean jj_3R_119() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_137()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_229()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3R_220() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_597()) { + jj_scanpos = xsp; + if (jj_3_598()) { + jj_scanpos = xsp; + if (jj_3_599()) { + jj_scanpos = xsp; + if (jj_3_600()) { + jj_scanpos = xsp; + if (jj_3_601()) { + jj_scanpos = xsp; + if (jj_3_602()) { + jj_scanpos = xsp; + if (jj_3_603()) { + jj_scanpos = xsp; + if (jj_3_604()) { + jj_scanpos = xsp; + if (jj_3_605()) return true; + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_593() { + if (jj_3R_224()) return true; + return false; + } + + final private boolean jj_3_592() { + if (jj_3R_223()) return true; + return false; + } + + final private boolean jj_3_591() { + if (jj_3R_222()) return true; + return false; + } + + final private boolean jj_3_590() { + if (jj_3R_221()) return true; + return false; + } + + final private boolean jj_3_589() { + if (jj_3R_220()) return true; + return false; + } + + final private boolean jj_3R_218() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_589()) { + jj_scanpos = xsp; + if (jj_3_590()) { + jj_scanpos = xsp; + if (jj_3_591()) { + jj_scanpos = xsp; + if (jj_3_592()) { + jj_scanpos = xsp; + if (jj_3_593()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_225() { + if (jj_scan_token(REPEATABLE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_588() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_1401() { + if (jj_scan_token(ZONE)) return true; + return false; + } + + final private boolean jj_3_1400() { + if (jj_scan_token(WORK)) return true; + return false; + } + + final private boolean jj_3_587() { + if (jj_3R_219()) return true; + return false; + } + + final private boolean jj_3_1399() { + if (jj_scan_token(WIDTH_BUCKET)) return true; + return false; + } + + final private boolean jj_3_1398() { + if (jj_scan_token(VIEW)) return true; + return false; + } + + final private boolean jj_3_224() { + if (jj_scan_token(SYSTEM)) return true; + return false; + } + + final private boolean jj_3_1397() { + if (jj_scan_token(VAR_SAMP)) return true; + return false; + } + + final private boolean jj_3_586() { + if (jj_3R_218()) return true; + return false; + } + + final private boolean jj_3_1396() { + if (jj_scan_token(VARCHAR)) return true; + return false; + } + + final private boolean jj_3_1395() { + if (jj_scan_token(VALUE)) return true; + return false; + } + + final private boolean jj_3_1394() { + if (jj_scan_token(UPSERT)) return true; + return false; + } + + final private boolean jj_3_1393() { + if (jj_scan_token(UNIQUE)) return true; + return false; + } + + final private boolean jj_3_223() { + if (jj_scan_token(BERNOULLI)) return true; + return false; + } + + final private boolean jj_3R_278() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_586()) { + jj_scanpos = xsp; + if (jj_3_587()) { + jj_scanpos = xsp; + if (jj_3_588()) return true; + } + } + return false; + } + + final private boolean jj_3_1392() { + if (jj_scan_token(TRUNCATE)) return true; + return false; + } + + final private boolean jj_3_1391() { + if (jj_scan_token(TRIM)) return true; + return false; + } + + final private boolean jj_3_1390() { + if (jj_scan_token(TRANSLATION)) return true; + return false; + } + + final private boolean jj_3_1389() { + if (jj_scan_token(TRANSACTION)) return true; + return false; + } + + final private boolean jj_3_1388() { + if (jj_scan_token(TINYINT)) return true; + return false; + } + + final private boolean jj_3_227() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_223()) { + jj_scanpos = xsp; + if (jj_3_224()) return true; + } + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_1387() { + if (jj_scan_token(TEMPORARY)) return true; + return false; + } + + final private boolean jj_3_1386() { + if (jj_scan_token(SYSTEM)) return true; + return false; + } + + final private boolean jj_3_1385() { + if (jj_scan_token(SUCCEEDS)) return true; + return false; + } + + final private boolean jj_3_1384() { + if (jj_scan_token(SUBSET)) return true; + return false; + } + + final private boolean jj_3_1383() { + if (jj_scan_token(STDDEV_POP)) return true; + return false; + } + + final private boolean jj_3_1382() { + if (jj_scan_token(START)) return true; + return false; + } + + final private boolean jj_3_1381() { + if (jj_scan_token(SQLSTATE)) return true; + return false; + } + + final private boolean jj_3_1380() { + if (jj_scan_token(SPECIFICTYPE)) return true; + return false; + } + + final private boolean jj_3_585() { + if (jj_3R_217()) return true; + return false; + } + + final private boolean jj_3_1379() { + if (jj_scan_token(SMALLINT)) return true; + return false; + } + + final private boolean jj_3_1378() { + if (jj_scan_token(SHOW)) return true; + return false; + } + + final private boolean jj_3_1377() { + if (jj_scan_token(SENSITIVE)) return true; + return false; + } + + final private boolean jj_3_226() { + if (jj_scan_token(SUBSTITUTE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_1376() { + if (jj_scan_token(SECOND)) return true; + return false; + } + + final private boolean jj_3_1375() { + if (jj_scan_token(SCOPE)) return true; + return false; + } + + final private boolean jj_3_1374() { + if (jj_scan_token(RUNNING)) return true; + return false; + } + + final private boolean jj_3_1373() { + if (jj_scan_token(ROLLBACK)) return true; + return false; + } + + final private boolean jj_3R_91() { + if (jj_3R_278()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_585()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_1372() { + if (jj_scan_token(RETURNS)) return true; + return false; + } + + final private boolean jj_3_1371() { + if (jj_scan_token(RESTRICT)) return true; + return false; + } + + final private boolean jj_3_228() { + if (jj_scan_token(TABLESAMPLE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_226()) { + jj_scanpos = xsp; + if (jj_3_227()) return true; + } + return false; + } + + final private boolean jj_3_1370() { + if (jj_scan_token(RELEASE)) return true; + return false; + } + + final private boolean jj_3_1369() { + if (jj_scan_token(REGR_SXY)) return true; + return false; + } + + final private boolean jj_3_1368() { + if (jj_scan_token(REGR_R2)) return true; + return false; + } + + final private boolean jj_3_1367() { + if (jj_scan_token(REGR_AVGY)) return true; + return false; + } + + final private boolean jj_3_1366() { + if (jj_scan_token(REFERENCES)) return true; + return false; + } + + final private boolean jj_3_1365() { + if (jj_scan_token(REAL)) return true; + return false; + } + + final private boolean jj_3_1364() { + if (jj_scan_token(RANK)) return true; + return false; + } + + final private boolean jj_3_1363() { + if (jj_scan_token(PROCEDURE)) return true; + return false; + } + + final private boolean jj_3_1362() { + if (jj_scan_token(PREV)) return true; + return false; + } + + final private boolean jj_3_1361() { + if (jj_scan_token(PRECISION)) return true; + return false; + } + + final private boolean jj_3_1360() { + if (jj_scan_token(POSITION_REGEX)) return true; + return false; + } + + final private boolean jj_3_1359() { + if (jj_scan_token(PERMUTE)) return true; + return false; + } + + final private boolean jj_3_1358() { + if (jj_scan_token(PERCENTILE_DISC)) return true; + return false; + } + + final private boolean jj_3_1357() { + if (jj_scan_token(PER)) return true; + return false; + } + + final private boolean jj_3_221() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_1356() { + if (jj_scan_token(PARAMETER)) return true; + return false; + } + + final private boolean jj_3_220() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_1355() { + if (jj_scan_token(OVERLAPS)) return true; + return false; + } + + final private boolean jj_3_584() { + if (jj_scan_token(MINUS)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_1354() { + if (jj_scan_token(ORDINALITY)) return true; + return false; + } + + final private boolean jj_3_222() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_220()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + xsp = jj_scanpos; + if (jj_3_221()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_1353() { + if (jj_scan_token(OPEN)) return true; + return false; + } + + final private boolean jj_3_1352() { + if (jj_scan_token(OMIT)) return true; + return false; + } + + final private boolean jj_3_1351() { + if (jj_scan_token(OCTET_LENGTH)) return true; + return false; + } + + final private boolean jj_3_1350() { + if (jj_scan_token(NUMERIC)) return true; + return false; + } + + final private boolean jj_3_219() { + if (jj_3R_136()) return true; + return false; + } + + final private boolean jj_3_1349() { + if (jj_scan_token(NTH_VALUE)) return true; + return false; + } + + final private boolean jj_3_1348() { + if (jj_scan_token(NONE)) return true; + return false; + } + + final private boolean jj_3_582() { + if (jj_scan_token(PLUS)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_1347() { + if (jj_scan_token(NCHAR)) return true; + return false; + } + + final private boolean jj_3_1346() { + if (jj_scan_token(NAME)) return true; + return false; + } + + final private boolean jj_3_218() { + if (jj_3R_135()) return true; + return false; + } + + final private boolean jj_3_581() { + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_1345() { + if (jj_scan_token(MODULE)) return true; + return false; + } + + final private boolean jj_3_1344() { + if (jj_scan_token(MINUTE)) return true; + return false; + } + + final private boolean jj_3_1343() { + if (jj_scan_token(MEMBER)) return true; + return false; + } + + final private boolean jj_3_217() { + if (jj_3R_134()) return true; + return false; + } + + final private boolean jj_3_1342() { + if (jj_scan_token(MATCH_NUMBER)) return true; + return false; + } + + final private boolean jj_3_1341() { + if (jj_scan_token(MAP)) return true; + return false; + } + + final private boolean jj_3_583() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_581()) { + jj_scanpos = xsp; + if (jj_3_582()) return true; + } + return false; + } + + final private boolean jj_3_1340() { + if (jj_scan_token(LOCATOR)) return true; + return false; + } + + final private boolean jj_3_1339() { + if (jj_scan_token(LOCAL)) return true; + return false; + } + + final private boolean jj_3_1338() { + if (jj_scan_token(LIKE)) return true; + return false; + } + + final private boolean jj_3_1337() { + if (jj_scan_token(LEADING)) return true; + return false; + } + + final private boolean jj_3_1336() { + if (jj_scan_token(LAST)) return true; + return false; + } + + final private boolean jj_3_1335() { + if (jj_scan_token(LAG)) return true; + return false; + } + + final private boolean jj_3_1334() { + if (jj_scan_token(JSON_VALUE)) return true; + return false; + } + + final private boolean jj_3_1333() { + if (jj_scan_token(JSON_OBJECT)) return true; + return false; + } + + final private boolean jj_3_212() { + if (jj_scan_token(LATERAL)) return true; + return false; + } + + final private boolean jj_3_1332() { + if (jj_scan_token(JSON_ARRAY)) return true; + return false; + } + + final private boolean jj_3_216() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_212()) jj_scanpos = xsp; + if (jj_scan_token(TABLE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_1331() { + if (jj_scan_token(INTERSECTION)) return true; + return false; + } + + final private boolean jj_3_1330() { + if (jj_scan_token(INSENSITIVE)) return true; + return false; + } + + final private boolean jj_3_1329() { + if (jj_scan_token(INITIALLY)) return true; + return false; + } + + final private boolean jj_3_1328() { + if (jj_scan_token(IMPORT)) return true; + return false; + } + + final private boolean jj_3_211() { + if (jj_scan_token(WITH)) return true; + if (jj_scan_token(ORDINALITY)) return true; + return false; + } + + final private boolean jj_3_1327() { + if (jj_scan_token(IDENTITY)) return true; + return false; + } + + final private boolean jj_3_1326() { + if (jj_scan_token(GROUPS)) return true; + return false; + } + + final private boolean jj_3R_210() { + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_1325() { + if (jj_scan_token(GLOBAL)) return true; + return false; + } + + final private boolean jj_3_1324() { + if (jj_scan_token(G)) return true; + return false; + } + + final private boolean jj_3_1323() { + if (jj_scan_token(FREE)) return true; + return false; + } + + final private boolean jj_3_1322() { + if (jj_scan_token(FOREIGN)) return true; + return false; + } + + final private boolean jj_3_210() { + if (jj_3R_129()) return true; + return false; + } + + final private boolean jj_3_1321() { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + final private boolean jj_3_215() { + if (jj_scan_token(UNNEST)) return true; + if (jj_3R_133()) return true; + return false; + } + + final private boolean jj_3_1320() { + if (jj_scan_token(FILTER)) return true; + return false; + } + + final private boolean jj_3_1319() { + if (jj_scan_token(EXTERNAL)) return true; + return false; + } + + final private boolean jj_3_1318() { + if (jj_scan_token(EXISTS)) return true; + return false; + } + + final private boolean jj_3_1317() { + if (jj_scan_token(EXCEPTION)) return true; + return false; + } + + final private boolean jj_3_1316() { + if (jj_scan_token(EQUALS)) return true; + return false; + } + + final private boolean jj_3_1315() { + if (jj_scan_token(END)) return true; + return false; + } + + final private boolean jj_3_1314() { + if (jj_scan_token(ELEMENT)) return true; + return false; + } + + final private boolean jj_3_1313() { + if (jj_scan_token(DOUBLE)) return true; + return false; + } + + final private boolean jj_3_1312() { + if (jj_scan_token(DISALLOW)) return true; + return false; + } + + final private boolean jj_3R_185() { + if (jj_scan_token(NEW)) return true; + if (jj_3R_276()) return true; + return false; + } + + final private boolean jj_3_1311() { + if (jj_scan_token(DESCRIPTOR)) return true; + return false; + } + + final private boolean jj_3_1310() { + if (jj_scan_token(DEPTH)) return true; + return false; + } + + final private boolean jj_3_1309() { + if (jj_scan_token(DEFERRABLE)) return true; + return false; + } + + final private boolean jj_3_1308() { + if (jj_scan_token(DEC)) return true; + return false; + } + + final private boolean jj_3_1307() { + if (jj_scan_token(DATE)) return true; + return false; + } + + final private boolean jj_3_1306() { + if (jj_scan_token(CURRENT_USER)) return true; + return false; + } + + final private boolean jj_3_209() { + if (jj_scan_token(LATERAL)) return true; + return false; + } + + final private boolean jj_3_1305() { + if (jj_scan_token(CURRENT_TIME)) return true; + return false; + } + + final private boolean jj_3_1304() { + if (jj_scan_token(CURRENT_ROLE)) return true; + return false; + } + + final private boolean jj_3_208() { + if (jj_3R_129()) return true; + return false; + } + + final private boolean jj_3_1303() { + if (jj_scan_token(CURRENT_DATE)) return true; + return false; + } + + final private boolean jj_3_214() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_209()) jj_scanpos = xsp; + if (jj_3R_132()) return true; + return false; + } + + final private boolean jj_3_1302() { + if (jj_scan_token(CUBE)) return true; + return false; + } + + final private boolean jj_3_1301() { + if (jj_scan_token(COUNT)) return true; + return false; + } + + final private boolean jj_3_207() { + if (jj_3R_128()) return true; + return false; + } + + final private boolean jj_3_1300() { + if (jj_scan_token(CONVERT)) return true; + return false; + } + + final private boolean jj_3_1299() { + if (jj_scan_token(CONSTRUCTOR)) return true; + return false; + } + + final private boolean jj_3_1298() { + if (jj_scan_token(CONNECT)) return true; + return false; + } + + final private boolean jj_3_1297() { + if (jj_scan_token(COLUMN)) return true; + return false; + } + + final private boolean jj_3_1296() { + if (jj_scan_token(COLLATE)) return true; + return false; + } + + final private boolean jj_3R_120() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_282()) return true; + return false; + } + + final private boolean jj_3_1295() { + if (jj_scan_token(CLOB)) return true; + return false; + } + + final private boolean jj_3_1294() { + if (jj_scan_token(CHAR_LENGTH)) return true; + return false; + } + + final private boolean jj_3_1293() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + final private boolean jj_3_1292() { + if (jj_scan_token(CATALOG)) return true; + return false; + } + + final private boolean jj_3_1291() { + if (jj_scan_token(CASCADE)) return true; + return false; + } + + final private boolean jj_3_205() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_1290() { + if (jj_scan_token(C)) return true; + return false; + } + + final private boolean jj_3_1289() { + if (jj_scan_token(BOTH)) return true; + return false; + } + + final private boolean jj_3_206() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_205()) jj_scanpos = xsp; + if (jj_3R_119()) return true; + return false; + } + + final private boolean jj_3_1288() { + if (jj_scan_token(BIT)) return true; + return false; + } + + final private boolean jj_3_1287() { + if (jj_scan_token(BETWEEN)) return true; + return false; + } + + final private boolean jj_3_1286() { + if (jj_scan_token(BEGIN)) return true; + return false; + } + + final private boolean jj_3_1285() { + if (jj_scan_token(AUTHORIZATION)) return true; + return false; + } + + final private boolean jj_3_1284() { + if (jj_scan_token(ASYMMETRIC)) return true; + return false; + } + + final private boolean jj_3_1283() { + if (jj_scan_token(ASC)) return true; + return false; + } + + final private boolean jj_3_1282() { + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_213() { + if (jj_3R_130()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_206()) jj_scanpos = xsp; + if (jj_3R_131()) return true; + xsp = jj_scanpos; + if (jj_3_207()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_208()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_580() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_216()) return true; + return false; + } + + final private boolean jj_3_1281() { + if (jj_scan_token(ALTER)) return true; + return false; + } + + final private boolean jj_3R_282() { + if (jj_3R_216()) return true; + return false; + } + + final private boolean jj_3_1280() { + if (jj_scan_token(AFTER)) return true; + return false; + } + + final private boolean jj_3_1279() { + if (jj_scan_token(ABSOLUTE)) return true; + return false; + } + + final private boolean jj_3_1278() { + if (jj_scan_token(UUID)) return true; + return false; + } + + final private boolean jj_3R_286() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_213()) { + jj_scanpos = xsp; + if (jj_3_214()) { + jj_scanpos = xsp; + if (jj_3_215()) { + jj_scanpos = xsp; + if (jj_3_216()) { + jj_scanpos = xsp; + if (jj_3_217()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_1277() { + if (jj_scan_token(COMPUTE)) return true; + return false; + } + + final private boolean jj_3_1276() { + if (jj_scan_token(SCAN)) return true; + return false; + } + + final private boolean jj_3_1275() { + if (jj_scan_token(NOLOGGING)) return true; + return false; + } + + final private boolean jj_3_1274() { + if (jj_scan_token(PARALLEL)) return true; + return false; + } + + final private boolean jj_3_1273() { + if (jj_scan_token(DATA_REGION)) return true; + return false; + } + + final private boolean jj_3_1272() { + if (jj_scan_token(WRITE_SYNCHRONIZATION_MODE)) return true; + return false; + } + + final private boolean jj_3_1271() { + if (jj_scan_token(BACKUPS)) return true; + return false; + } + + final private boolean jj_3_579() { + if (jj_scan_token(DOT)) return true; + if (jj_3R_215()) return true; + return false; + } + + final private boolean jj_3R_269() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_1271()) { + jj_scanpos = xsp; + if (jj_3_1272()) { + jj_scanpos = xsp; + if (jj_3_1273()) { + jj_scanpos = xsp; + if (jj_3_1274()) { + jj_scanpos = xsp; + if (jj_3_1275()) { + jj_scanpos = xsp; + if (jj_3_1276()) { + jj_scanpos = xsp; + if (jj_3_1277()) { + jj_scanpos = xsp; + if (jj_3_1278()) { + jj_scanpos = xsp; + if (jj_3_1279()) { + jj_scanpos = xsp; + if (jj_3_1280()) { + jj_scanpos = xsp; + if (jj_3_1281()) { + jj_scanpos = xsp; + if (jj_3_1282()) { + jj_scanpos = xsp; + if (jj_3_1283()) { + jj_scanpos = xsp; + if (jj_3_1284()) { + jj_scanpos = xsp; + if (jj_3_1285()) { + jj_scanpos = xsp; + if (jj_3_1286()) { + jj_scanpos = xsp; + if (jj_3_1287()) { + jj_scanpos = xsp; + if (jj_3_1288()) { + jj_scanpos = xsp; + if (jj_3_1289()) { + jj_scanpos = xsp; + if (jj_3_1290()) { + jj_scanpos = xsp; + if (jj_3_1291()) { + jj_scanpos = xsp; + if (jj_3_1292()) { + jj_scanpos = xsp; + if (jj_3_1293()) { + jj_scanpos = xsp; + if (jj_3_1294()) { + jj_scanpos = xsp; + if (jj_3_1295()) { + jj_scanpos = xsp; + if (jj_3_1296()) { + jj_scanpos = xsp; + if (jj_3_1297()) { + jj_scanpos = xsp; + if (jj_3_1298()) { + jj_scanpos = xsp; + if (jj_3_1299()) { + jj_scanpos = xsp; + if (jj_3_1300()) { + jj_scanpos = xsp; + if (jj_3_1301()) { + jj_scanpos = xsp; + if (jj_3_1302()) { + jj_scanpos = xsp; + if (jj_3_1303()) { + jj_scanpos = xsp; + if (jj_3_1304()) { + jj_scanpos = xsp; + if (jj_3_1305()) { + jj_scanpos = xsp; + if (jj_3_1306()) { + jj_scanpos = xsp; + if (jj_3_1307()) { + jj_scanpos = xsp; + if (jj_3_1308()) { + jj_scanpos = xsp; + if (jj_3_1309()) { + jj_scanpos = xsp; + if (jj_3_1310()) { + jj_scanpos = xsp; + if (jj_3_1311()) { + jj_scanpos = xsp; + if (jj_3_1312()) { + jj_scanpos = xsp; + if (jj_3_1313()) { + jj_scanpos = xsp; + if (jj_3_1314()) { + jj_scanpos = xsp; + if (jj_3_1315()) { + jj_scanpos = xsp; + if (jj_3_1316()) { + jj_scanpos = xsp; + if (jj_3_1317()) { + jj_scanpos = xsp; + if (jj_3_1318()) { + jj_scanpos = xsp; + if (jj_3_1319()) { + jj_scanpos = xsp; + if (jj_3_1320()) { + jj_scanpos = xsp; + if (jj_3_1321()) { + jj_scanpos = xsp; + if (jj_3_1322()) { + jj_scanpos = xsp; + if (jj_3_1323()) { + jj_scanpos = xsp; + if (jj_3_1324()) { + jj_scanpos = xsp; + if (jj_3_1325()) { + jj_scanpos = xsp; + if (jj_3_1326()) { + jj_scanpos = xsp; + if (jj_3_1327()) { + jj_scanpos = xsp; + if (jj_3_1328()) { + jj_scanpos = xsp; + if (jj_3_1329()) { + jj_scanpos = xsp; + if (jj_3_1330()) { + jj_scanpos = xsp; + if (jj_3_1331()) { + jj_scanpos = xsp; + if (jj_3_1332()) { + jj_scanpos = xsp; + if (jj_3_1333()) { + jj_scanpos = xsp; + if (jj_3_1334()) { + jj_scanpos = xsp; + if (jj_3_1335()) { + jj_scanpos = xsp; + if (jj_3_1336()) { + jj_scanpos = xsp; + if (jj_3_1337()) { + jj_scanpos = xsp; + if (jj_3_1338()) { + jj_scanpos = xsp; + if (jj_3_1339()) { + jj_scanpos = xsp; + if (jj_3_1340()) { + jj_scanpos = xsp; + if (jj_3_1341()) { + jj_scanpos = xsp; + if (jj_3_1342()) { + jj_scanpos = xsp; + if (jj_3_1343()) { + jj_scanpos = xsp; + if (jj_3_1344()) { + jj_scanpos = xsp; + if (jj_3_1345()) { + jj_scanpos = xsp; + if (jj_3_1346()) { + jj_scanpos = xsp; + if (jj_3_1347()) { + jj_scanpos = xsp; + if (jj_3_1348()) { + jj_scanpos = xsp; + if (jj_3_1349()) { + jj_scanpos = xsp; + if (jj_3_1350()) { + jj_scanpos = xsp; + if (jj_3_1351()) { + jj_scanpos = xsp; + if (jj_3_1352()) { + jj_scanpos = xsp; + if (jj_3_1353()) { + jj_scanpos = xsp; + if (jj_3_1354()) { + jj_scanpos = xsp; + if (jj_3_1355()) { + jj_scanpos = xsp; + if (jj_3_1356()) { + jj_scanpos = xsp; + if (jj_3_1357()) { + jj_scanpos = xsp; + if (jj_3_1358()) { + jj_scanpos = xsp; + if (jj_3_1359()) { + jj_scanpos = xsp; + if (jj_3_1360()) { + jj_scanpos = xsp; + if (jj_3_1361()) { + jj_scanpos = xsp; + if (jj_3_1362()) { + jj_scanpos = xsp; + if (jj_3_1363()) { + jj_scanpos = xsp; + if (jj_3_1364()) { + jj_scanpos = xsp; + if (jj_3_1365()) { + jj_scanpos = xsp; + if (jj_3_1366()) { + jj_scanpos = xsp; + if (jj_3_1367()) { + jj_scanpos = xsp; + if (jj_3_1368()) { + jj_scanpos = xsp; + if (jj_3_1369()) { + jj_scanpos = xsp; + if (jj_3_1370()) { + jj_scanpos = xsp; + if (jj_3_1371()) { + jj_scanpos = xsp; + if (jj_3_1372()) { + jj_scanpos = xsp; + if (jj_3_1373()) { + jj_scanpos = xsp; + if (jj_3_1374()) { + jj_scanpos = xsp; + if (jj_3_1375()) { + jj_scanpos = xsp; + if (jj_3_1376()) { + jj_scanpos = xsp; + if (jj_3_1377()) { + jj_scanpos = xsp; + if (jj_3_1378()) { + jj_scanpos = xsp; + if (jj_3_1379()) { + jj_scanpos = xsp; + if (jj_3_1380()) { + jj_scanpos = xsp; + if (jj_3_1381()) { + jj_scanpos = xsp; + if (jj_3_1382()) { + jj_scanpos = xsp; + if (jj_3_1383()) { + jj_scanpos = xsp; + if (jj_3_1384()) { + jj_scanpos = xsp; + if (jj_3_1385()) { + jj_scanpos = xsp; + if (jj_3_1386()) { + jj_scanpos = xsp; + if (jj_3_1387()) { + jj_scanpos = xsp; + if (jj_3_1388()) { + jj_scanpos = xsp; + if (jj_3_1389()) { + jj_scanpos = xsp; + if (jj_3_1390()) { + jj_scanpos = xsp; + if (jj_3_1391()) { + jj_scanpos = xsp; + if (jj_3_1392()) { + jj_scanpos = xsp; + if (jj_3_1393()) { + jj_scanpos = xsp; + if (jj_3_1394()) { + jj_scanpos = xsp; + if (jj_3_1395()) { + jj_scanpos = xsp; + if (jj_3_1396()) { + jj_scanpos = xsp; + if (jj_3_1397()) { + jj_scanpos = xsp; + if (jj_3_1398()) { + jj_scanpos = xsp; + if (jj_3_1399()) { + jj_scanpos = xsp; + if (jj_3_1400()) { + jj_scanpos = xsp; + if (jj_3_1401()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3R_287() { + if (jj_3R_215()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_579()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_1270() { + if (jj_scan_token(YEAR)) return true; + return false; + } + + final private boolean jj_3_1269() { + if (jj_scan_token(WITHOUT)) return true; + return false; + } + + final private boolean jj_3_1268() { + if (jj_scan_token(WHENEVER)) return true; + return false; + } + + final private boolean jj_3_1267() { + if (jj_scan_token(VERSIONING)) return true; + return false; + } + + final private boolean jj_3_1266() { + if (jj_scan_token(VAR_POP)) return true; + return false; + } + + final private boolean jj_3_1265() { + if (jj_scan_token(VARBINARY)) return true; + return false; + } + + final private boolean jj_3_1264() { + if (jj_scan_token(USER)) return true; + return false; + } + + final private boolean jj_3_1263() { + if (jj_scan_token(UPPER)) return true; + return false; + } + + final private boolean jj_3_1262() { + if (jj_scan_token(UNDER)) return true; + return false; + } + + final private boolean jj_3R_127() { + if (jj_3R_286()) return true; + return false; + } + + final private boolean jj_3_1261() { + if (jj_scan_token(TRUE)) return true; + return false; + } + + final private boolean jj_3_1260() { + if (jj_scan_token(TRIGGER)) return true; + return false; + } + + final private boolean jj_3_1259() { + if (jj_scan_token(TRANSLATE_REGEX)) return true; + return false; + } + + final private boolean jj_3_1258() { + if (jj_scan_token(TRAILING)) return true; + return false; + } + + final private boolean jj_3_1257() { + if (jj_scan_token(TIMEZONE_MINUTE)) return true; + return false; + } + + final private boolean jj_3_1256() { + if (jj_scan_token(SYSTEM_USER)) return true; + return false; + } + + final private boolean jj_3_1255() { + if (jj_scan_token(SYMMETRIC)) return true; + return false; + } + + final private boolean jj_3_1254() { + if (jj_scan_token(SUBSTRING_REGEX)) return true; + return false; + } + + final private boolean jj_3_1253() { + if (jj_scan_token(SUBMULTISET)) return true; + return false; + } + + final private boolean jj_3_1252() { + if (jj_scan_token(STATIC)) return true; + return false; + } + + final private boolean jj_3_1251() { + if (jj_scan_token(SQRT)) return true; + return false; + } + + final private boolean jj_3_1250() { + if (jj_scan_token(SQLEXCEPTION)) return true; + return false; + } + + final private boolean jj_3_1249() { + if (jj_scan_token(SPECIFIC)) return true; + return false; + } + + final private boolean jj_3_1248() { + if (jj_scan_token(SIZE)) return true; + return false; + } + + final private boolean jj_3_578() { + if (jj_scan_token(DOT)) return true; + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_1247() { + if (jj_scan_token(SESSION_USER)) return true; + return false; + } + + final private boolean jj_3_1246() { + if (jj_scan_token(SEEK)) return true; + return false; + } + + final private boolean jj_3_1245() { + if (jj_scan_token(SEARCH)) return true; + return false; + } + + final private boolean jj_3_1244() { + if (jj_scan_token(SCHEMA)) return true; + return false; + } + + final private boolean jj_3_1243() { + if (jj_scan_token(ROW_NUMBER)) return true; + return false; + } + + final private boolean jj_3_577() { + if (jj_scan_token(DOT)) return true; + if (jj_3R_214()) return true; + return false; + } + + final private boolean jj_3_1242() { + if (jj_scan_token(ROLE)) return true; + return false; + } + + final private boolean jj_3_1241() { + if (jj_scan_token(RETURN)) return true; + return false; + } + + final private boolean jj_3_1240() { + if (jj_scan_token(RESET)) return true; + return false; + } + + final private boolean jj_3_204() { + if (jj_scan_token(OUTER)) return true; + if (jj_scan_token(APPLY)) return true; + return false; + } + + final private boolean jj_3_1239() { + if (jj_scan_token(RELATIVE)) return true; + return false; + } + + final private boolean jj_3_1238() { + if (jj_scan_token(REGR_SXX)) return true; + return false; + } + + final private boolean jj_3R_116() { + if (jj_3R_214()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_577()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3_578()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_1237() { + if (jj_scan_token(REGR_INTERCEPT)) return true; + return false; + } + + final private boolean jj_3_1236() { + if (jj_scan_token(REGR_AVGX)) return true; + return false; + } + + final private boolean jj_3_1235() { + if (jj_scan_token(REF)) return true; + return false; + } + + final private boolean jj_3_1234() { + if (jj_scan_token(READS)) return true; + return false; + } + + final private boolean jj_3_1233() { + if (jj_scan_token(QUARTER)) return true; + return false; + } + + final private boolean jj_3_1232() { + if (jj_scan_token(PRIVILEGES)) return true; + return false; + } + + final private boolean jj_3_1231() { + if (jj_scan_token(PRESERVE)) return true; + return false; + } + + final private boolean jj_3_1230() { + if (jj_scan_token(PRECEDES)) return true; + return false; + } + + final private boolean jj_3_1229() { + if (jj_scan_token(POSITION)) return true; + return false; + } + + final private boolean jj_3_1228() { + if (jj_scan_token(PERIOD)) return true; + return false; + } + + final private boolean jj_3_1227() { + if (jj_scan_token(PERCENTILE_CONT)) return true; + return false; + } + + final private boolean jj_3_1226() { + if (jj_scan_token(PATH)) return true; + return false; + } + + final private boolean jj_3_203() { + if (jj_scan_token(CROSS)) return true; + if (jj_scan_token(APPLY)) return true; + return false; + } + + final private boolean jj_3_1225() { + if (jj_scan_token(PAD)) return true; + return false; + } + + final private boolean jj_3_1224() { + if (jj_scan_token(OUTPUT)) return true; + return false; + } + + final private boolean jj_3_1223() { + if (jj_scan_token(OR)) return true; + return false; + } + + final private boolean jj_3_1222() { + if (jj_scan_token(ONLY)) return true; + return false; + } + + final private boolean jj_3_576() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_1221() { + if (jj_scan_token(OLD)) return true; + return false; + } + + final private boolean jj_3_1220() { + if (jj_scan_token(OCCURRENCES_REGEX)) return true; + return false; + } + + final private boolean jj_3_1219() { + if (jj_scan_token(NULLIF)) return true; + return false; + } + + final private boolean jj_3R_106() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_575()) { + jj_scanpos = xsp; + if (jj_3_576()) return true; + } + return false; + } + + final private boolean jj_3_1218() { + if (jj_scan_token(NOT)) return true; + return false; + } + + final private boolean jj_3_575() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_1217() { + if (jj_scan_token(NO)) return true; + return false; + } + + final private boolean jj_3_1216() { + if (jj_scan_token(NATIONAL)) return true; + return false; + } + + final private boolean jj_3_1215() { + if (jj_scan_token(MULTISET)) return true; + return false; + } + + final private boolean jj_3_202() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_127()) return true; + return false; + } + + final private boolean jj_3_1214() { + if (jj_scan_token(MODIFIES)) return true; + return false; + } + + final private boolean jj_3_1213() { + if (jj_scan_token(MIN)) return true; + return false; + } + + final private boolean jj_3_1212() { + if (jj_scan_token(MEASURES)) return true; + return false; + } + + final private boolean jj_3_1211() { + if (jj_scan_token(MATCHES)) return true; + return false; + } + + final private boolean jj_3_1210() { + if (jj_scan_token(M)) return true; + return false; + } + + final private boolean jj_3_1209() { + if (jj_scan_token(LOCALTIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_1208() { + if (jj_scan_token(LN)) return true; + return false; + } + + final private boolean jj_3_1207() { + if (jj_scan_token(LEVEL)) return true; + return false; + } + + final private boolean jj_3_1206() { + if (jj_scan_token(LEAD)) return true; + return false; + } + + final private boolean jj_3_1205() { + if (jj_scan_token(LARGE)) return true; + return false; + } + + final private boolean jj_3_1204() { + if (jj_scan_token(KEY)) return true; + return false; + } + + final private boolean jj_3_1203() { + if (jj_scan_token(JSON_QUERY)) return true; + return false; + } + + final private boolean jj_3_1202() { + if (jj_scan_token(JSON_EXISTS)) return true; + return false; + } + + final private boolean jj_3_1201() { + if (jj_scan_token(ISOLATION)) return true; + return false; + } + + final private boolean jj_3_1200() { + if (jj_scan_token(INTEGER)) return true; + return false; + } + + final private boolean jj_3_1199() { + if (jj_scan_token(INPUT)) return true; + return false; + } + + final private boolean jj_3R_96() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_279()) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_1198() { + if (jj_scan_token(INITIAL)) return true; + return false; + } + + final private boolean jj_3_1197() { + if (jj_scan_token(IMMEDIATELY)) return true; + return false; + } + + final private boolean jj_3_1196() { + if (jj_scan_token(HOUR)) return true; + return false; + } + + final private boolean jj_3_1195() { + if (jj_scan_token(GOTO)) return true; + return false; + } + + final private boolean jj_3_1194() { + if (jj_scan_token(GET)) return true; + return false; + } + + final private boolean jj_3_1193() { + if (jj_scan_token(FUSION)) return true; + return false; + } + + final private boolean jj_3_1192() { + if (jj_scan_token(FRAME_ROW)) return true; + return false; + } + + final private boolean jj_3_1191() { + if (jj_scan_token(FOR)) return true; + return false; + } + + final private boolean jj_3_1190() { + if (jj_scan_token(FIRST_VALUE)) return true; + return false; + } + + final private boolean jj_3_200() { + if (jj_scan_token(USING)) return true; + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_1189() { + if (jj_scan_token(FALSE)) return true; + return false; + } + + final private boolean jj_3_1188() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_1187() { + if (jj_scan_token(EXECUTE)) return true; + return false; + } + + final private boolean jj_3_1186() { + if (jj_scan_token(EVERY)) return true; + return false; + } + + final private boolean jj_3_574() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_1185() { + if (jj_scan_token(END_PARTITION)) return true; + return false; + } + + final private boolean jj_3_1184() { + if (jj_scan_token(EMPTY)) return true; + return false; + } + + final private boolean jj_3_1183() { + if (jj_scan_token(EACH)) return true; + return false; + } + + final private boolean jj_3_1182() { + if (jj_scan_token(DOMAIN)) return true; + return false; + } + + final private boolean jj_3_1181() { + if (jj_scan_token(DIAGNOSTICS)) return true; + return false; + } + + final private boolean jj_3R_279() { + if (jj_3R_66()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_574()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_1180() { + if (jj_scan_token(DESC)) return true; + return false; + } + + final private boolean jj_3_1179() { + if (jj_scan_token(DENSE_RANK)) return true; + return false; + } + + final private boolean jj_3_1178() { + if (jj_scan_token(DECLARE)) return true; + return false; + } + + final private boolean jj_3_1177() { + if (jj_scan_token(DEALLOCATE)) return true; + return false; + } + + final private boolean jj_3_199() { + if (jj_scan_token(ON)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_1176() { + if (jj_scan_token(DATA)) return true; + return false; + } + + final private boolean jj_3_1175() { + if (jj_scan_token(CURRENT_TRANSFORM_GROUP_FOR_TYPE)) return true; + return false; + } + + final private boolean jj_3_1174() { + if (jj_scan_token(CURRENT_SCHEMA)) return true; + return false; + } + + final private boolean jj_3_1173() { + if (jj_scan_token(CURRENT_PATH)) return true; + return false; + } + + final private boolean jj_3_1172() { + if (jj_scan_token(CURRENT_CATALOG)) return true; + return false; + } + + final private boolean jj_3_1171() { + if (jj_scan_token(COVAR_SAMP)) return true; + return false; + } + + final private boolean jj_3_1170() { + if (jj_scan_token(CORRESPONDING)) return true; + return false; + } + + final private boolean jj_3_1169() { + if (jj_scan_token(CONTINUE)) return true; + return false; + } + + final private boolean jj_3_1168() { + if (jj_scan_token(CONSTRAINTS)) return true; + return false; + } + + final private boolean jj_3_201() { + if (jj_3R_125()) return true; + if (jj_3R_126()) return true; + if (jj_3R_127()) return true; + return false; + } + + final private boolean jj_3_1167() { + if (jj_scan_token(CONDITION)) return true; + return false; + } + + final private boolean jj_3_1166() { + if (jj_scan_token(COLLECT)) return true; + return false; + } + + final private boolean jj_3_1165() { + if (jj_scan_token(COALESCE)) return true; + return false; + } + + final private boolean jj_3_1164() { + if (jj_scan_token(CLASSIFIER)) return true; + return false; + } + + final private boolean jj_3R_284() { + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_1163() { + if (jj_scan_token(CHARACTER_LENGTH)) return true; + return false; + } + + final private boolean jj_3_1162() { + if (jj_scan_token(CEILING)) return true; + return false; + } + + final private boolean jj_3_1161() { + if (jj_scan_token(CAST)) return true; + return false; + } + + final private boolean jj_3_1160() { + if (jj_scan_token(CARDINALITY)) return true; + return false; + } + + final private boolean jj_3_1159() { + if (jj_scan_token(BY)) return true; + return false; + } + + final private boolean jj_3_1158() { + if (jj_scan_token(BOOLEAN)) return true; + return false; + } + + final private boolean jj_3_1157() { + if (jj_scan_token(BINARY)) return true; + return false; + } + + final private boolean jj_3_1156() { + if (jj_scan_token(BEGIN_PARTITION)) return true; + return false; + } + + final private boolean jj_3_1155() { + if (jj_scan_token(BEFORE)) return true; + return false; + } + + final private boolean jj_3_1154() { + if (jj_scan_token(ATOMIC)) return true; + return false; + } + + final private boolean jj_3_1153() { + if (jj_scan_token(ASSERTION)) return true; + return false; + } + + final private boolean jj_3_1152() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_198() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_201()) { + jj_scanpos = xsp; + if (jj_3_202()) { + jj_scanpos = xsp; + if (jj_3_203()) { + jj_scanpos = xsp; + if (jj_3_204()) return true; + } + } + } + return false; + } + + final private boolean jj_3_1151() { + if (jj_scan_token(ARE)) return true; + return false; + } + + final private boolean jj_3R_66() { + if (jj_3R_214()) return true; + return false; + } + + final private boolean jj_3_1150() { + if (jj_scan_token(ALLOW)) return true; + return false; + } + + final private boolean jj_3_1149() { + if (jj_scan_token(ADD)) return true; + return false; + } + + final private boolean jj_3_1148() { + if (jj_scan_token(ABS)) return true; + return false; + } + + final private boolean jj_3_1147() { + if (jj_scan_token(QUERY)) return true; + return false; + } + + final private boolean jj_3_1146() { + if (jj_scan_token(SERVICE)) return true; + return false; + } + + final private boolean jj_3R_114() { + if (jj_3R_127()) return true; + return false; + } + + final private boolean jj_3_1145() { + if (jj_scan_token(KILL)) return true; + return false; + } + + final private boolean jj_3_1144() { + if (jj_scan_token(LOGGING)) return true; + return false; + } + + final private boolean jj_3_1143() { + if (jj_scan_token(ENCRYPTED)) return true; + return false; + } + + final private boolean jj_3_1142() { + if (jj_scan_token(CACHE_NAME)) return true; + return false; + } + + final private boolean jj_3_1141() { + if (jj_scan_token(ATOMICITY)) return true; + return false; + } + + final private boolean jj_3_1140() { + if (jj_scan_token(TEMPLATE)) return true; + return false; + } + + final private boolean jj_3R_261() { + if (jj_3R_214()) return true; + return false; + } + + final private boolean jj_3R_268() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_1140()) { + jj_scanpos = xsp; + if (jj_3_1141()) { + jj_scanpos = xsp; + if (jj_3_1142()) { + jj_scanpos = xsp; + if (jj_3_1143()) { + jj_scanpos = xsp; + if (jj_3_1144()) { + jj_scanpos = xsp; + if (jj_3_1145()) { + jj_scanpos = xsp; + if (jj_3_1146()) { + jj_scanpos = xsp; + if (jj_3_1147()) { + jj_scanpos = xsp; + if (jj_3_1148()) { + jj_scanpos = xsp; + if (jj_3_1149()) { + jj_scanpos = xsp; + if (jj_3_1150()) { + jj_scanpos = xsp; + if (jj_3_1151()) { + jj_scanpos = xsp; + if (jj_3_1152()) { + jj_scanpos = xsp; + if (jj_3_1153()) { + jj_scanpos = xsp; + if (jj_3_1154()) { + jj_scanpos = xsp; + if (jj_3_1155()) { + jj_scanpos = xsp; + if (jj_3_1156()) { + jj_scanpos = xsp; + if (jj_3_1157()) { + jj_scanpos = xsp; + if (jj_3_1158()) { + jj_scanpos = xsp; + if (jj_3_1159()) { + jj_scanpos = xsp; + if (jj_3_1160()) { + jj_scanpos = xsp; + if (jj_3_1161()) { + jj_scanpos = xsp; + if (jj_3_1162()) { + jj_scanpos = xsp; + if (jj_3_1163()) { + jj_scanpos = xsp; + if (jj_3_1164()) { + jj_scanpos = xsp; + if (jj_3_1165()) { + jj_scanpos = xsp; + if (jj_3_1166()) { + jj_scanpos = xsp; + if (jj_3_1167()) { + jj_scanpos = xsp; + if (jj_3_1168()) { + jj_scanpos = xsp; + if (jj_3_1169()) { + jj_scanpos = xsp; + if (jj_3_1170()) { + jj_scanpos = xsp; + if (jj_3_1171()) { + jj_scanpos = xsp; + if (jj_3_1172()) { + jj_scanpos = xsp; + if (jj_3_1173()) { + jj_scanpos = xsp; + if (jj_3_1174()) { + jj_scanpos = xsp; + if (jj_3_1175()) { + jj_scanpos = xsp; + if (jj_3_1176()) { + jj_scanpos = xsp; + if (jj_3_1177()) { + jj_scanpos = xsp; + if (jj_3_1178()) { + jj_scanpos = xsp; + if (jj_3_1179()) { + jj_scanpos = xsp; + if (jj_3_1180()) { + jj_scanpos = xsp; + if (jj_3_1181()) { + jj_scanpos = xsp; + if (jj_3_1182()) { + jj_scanpos = xsp; + if (jj_3_1183()) { + jj_scanpos = xsp; + if (jj_3_1184()) { + jj_scanpos = xsp; + if (jj_3_1185()) { + jj_scanpos = xsp; + if (jj_3_1186()) { + jj_scanpos = xsp; + if (jj_3_1187()) { + jj_scanpos = xsp; + if (jj_3_1188()) { + jj_scanpos = xsp; + if (jj_3_1189()) { + jj_scanpos = xsp; + if (jj_3_1190()) { + jj_scanpos = xsp; + if (jj_3_1191()) { + jj_scanpos = xsp; + if (jj_3_1192()) { + jj_scanpos = xsp; + if (jj_3_1193()) { + jj_scanpos = xsp; + if (jj_3_1194()) { + jj_scanpos = xsp; + if (jj_3_1195()) { + jj_scanpos = xsp; + if (jj_3_1196()) { + jj_scanpos = xsp; + if (jj_3_1197()) { + jj_scanpos = xsp; + if (jj_3_1198()) { + jj_scanpos = xsp; + if (jj_3_1199()) { + jj_scanpos = xsp; + if (jj_3_1200()) { + jj_scanpos = xsp; + if (jj_3_1201()) { + jj_scanpos = xsp; + if (jj_3_1202()) { + jj_scanpos = xsp; + if (jj_3_1203()) { + jj_scanpos = xsp; + if (jj_3_1204()) { + jj_scanpos = xsp; + if (jj_3_1205()) { + jj_scanpos = xsp; + if (jj_3_1206()) { + jj_scanpos = xsp; + if (jj_3_1207()) { + jj_scanpos = xsp; + if (jj_3_1208()) { + jj_scanpos = xsp; + if (jj_3_1209()) { + jj_scanpos = xsp; + if (jj_3_1210()) { + jj_scanpos = xsp; + if (jj_3_1211()) { + jj_scanpos = xsp; + if (jj_3_1212()) { + jj_scanpos = xsp; + if (jj_3_1213()) { + jj_scanpos = xsp; + if (jj_3_1214()) { + jj_scanpos = xsp; + if (jj_3_1215()) { + jj_scanpos = xsp; + if (jj_3_1216()) { + jj_scanpos = xsp; + if (jj_3_1217()) { + jj_scanpos = xsp; + if (jj_3_1218()) { + jj_scanpos = xsp; + if (jj_3_1219()) { + jj_scanpos = xsp; + if (jj_3_1220()) { + jj_scanpos = xsp; + if (jj_3_1221()) { + jj_scanpos = xsp; + if (jj_3_1222()) { + jj_scanpos = xsp; + if (jj_3_1223()) { + jj_scanpos = xsp; + if (jj_3_1224()) { + jj_scanpos = xsp; + if (jj_3_1225()) { + jj_scanpos = xsp; + if (jj_3_1226()) { + jj_scanpos = xsp; + if (jj_3_1227()) { + jj_scanpos = xsp; + if (jj_3_1228()) { + jj_scanpos = xsp; + if (jj_3_1229()) { + jj_scanpos = xsp; + if (jj_3_1230()) { + jj_scanpos = xsp; + if (jj_3_1231()) { + jj_scanpos = xsp; + if (jj_3_1232()) { + jj_scanpos = xsp; + if (jj_3_1233()) { + jj_scanpos = xsp; + if (jj_3_1234()) { + jj_scanpos = xsp; + if (jj_3_1235()) { + jj_scanpos = xsp; + if (jj_3_1236()) { + jj_scanpos = xsp; + if (jj_3_1237()) { + jj_scanpos = xsp; + if (jj_3_1238()) { + jj_scanpos = xsp; + if (jj_3_1239()) { + jj_scanpos = xsp; + if (jj_3_1240()) { + jj_scanpos = xsp; + if (jj_3_1241()) { + jj_scanpos = xsp; + if (jj_3_1242()) { + jj_scanpos = xsp; + if (jj_3_1243()) { + jj_scanpos = xsp; + if (jj_3_1244()) { + jj_scanpos = xsp; + if (jj_3_1245()) { + jj_scanpos = xsp; + if (jj_3_1246()) { + jj_scanpos = xsp; + if (jj_3_1247()) { + jj_scanpos = xsp; + if (jj_3_1248()) { + jj_scanpos = xsp; + if (jj_3_1249()) { + jj_scanpos = xsp; + if (jj_3_1250()) { + jj_scanpos = xsp; + if (jj_3_1251()) { + jj_scanpos = xsp; + if (jj_3_1252()) { + jj_scanpos = xsp; + if (jj_3_1253()) { + jj_scanpos = xsp; + if (jj_3_1254()) { + jj_scanpos = xsp; + if (jj_3_1255()) { + jj_scanpos = xsp; + if (jj_3_1256()) { + jj_scanpos = xsp; + if (jj_3_1257()) { + jj_scanpos = xsp; + if (jj_3_1258()) { + jj_scanpos = xsp; + if (jj_3_1259()) { + jj_scanpos = xsp; + if (jj_3_1260()) { + jj_scanpos = xsp; + if (jj_3_1261()) { + jj_scanpos = xsp; + if (jj_3_1262()) { + jj_scanpos = xsp; + if (jj_3_1263()) { + jj_scanpos = xsp; + if (jj_3_1264()) { + jj_scanpos = xsp; + if (jj_3_1265()) { + jj_scanpos = xsp; + if (jj_3_1266()) { + jj_scanpos = xsp; + if (jj_3_1267()) { + jj_scanpos = xsp; + if (jj_3_1268()) { + jj_scanpos = xsp; + if (jj_3_1269()) { + jj_scanpos = xsp; + if (jj_3_1270()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_1139() { + if (jj_scan_token(WRITE)) return true; + return false; + } + + final private boolean jj_3_1138() { + if (jj_scan_token(WITHIN)) return true; + return false; + } + + final private boolean jj_3_1137() { + if (jj_scan_token(WEEK)) return true; + return false; + } + + final private boolean jj_3_1136() { + if (jj_scan_token(VERSION)) return true; + return false; + } + + final private boolean jj_3_1135() { + if (jj_scan_token(VARYING)) return true; + return false; + } + + final private boolean jj_3_1134() { + if (jj_scan_token(VALUE_OF)) return true; + return false; + } + + final private boolean jj_3_1133() { + if (jj_scan_token(USAGE)) return true; + return false; + } + + final private boolean jj_3_1132() { + if (jj_scan_token(UNKNOWN)) return true; + return false; + } + + final private boolean jj_3_1131() { + if (jj_scan_token(UESCAPE)) return true; + return false; + } + + final private boolean jj_3_1130() { + if (jj_scan_token(TRIM_ARRAY)) return true; + return false; + } + + final private boolean jj_3_1129() { + if (jj_scan_token(TREAT)) return true; + return false; + } + + final private boolean jj_3_1128() { + if (jj_scan_token(TRANSLATE)) return true; + return false; + } + + final private boolean jj_3_1127() { + if (jj_scan_token(TO)) return true; + return false; + } + + final private boolean jj_3_1126() { + if (jj_scan_token(TIMEZONE_HOUR)) return true; + return false; + } + + final private boolean jj_3_1125() { + if (jj_scan_token(SYSTEM_TIME)) return true; + return false; + } + + final private boolean jj_3_1124() { + if (jj_scan_token(SUM)) return true; + return false; + } + + final private boolean jj_3_1123() { + if (jj_scan_token(SUBSTRING)) return true; + return false; + } + + final private boolean jj_3_1122() { + if (jj_scan_token(STDDEV_SAMP)) return true; + return false; + } + + final private boolean jj_3_1121() { + if (jj_scan_token(STATE)) return true; + return false; + } + + final private boolean jj_3_1120() { + if (jj_scan_token(SQLWARNING)) return true; + return false; + } + + final private boolean jj_3_1119() { + if (jj_scan_token(SQL)) return true; + return false; + } + + final private boolean jj_3R_215() { + if (jj_3R_214()) return true; + return false; + } + + final private boolean jj_3_1118() { + if (jj_scan_token(SPACE)) return true; + return false; + } + + final private boolean jj_3_1117() { + if (jj_scan_token(SIMILAR)) return true; + return false; + } + + final private boolean jj_3_1116() { + if (jj_scan_token(SESSION)) return true; + return false; + } + + final private boolean jj_3_1115() { + if (jj_scan_token(SECTION)) return true; + return false; + } + + final private boolean jj_3_1114() { + if (jj_scan_token(SCROLL)) return true; + return false; + } + + final private boolean jj_3_1113() { + if (jj_scan_token(SAVEPOINT)) return true; + return false; + } + + final private boolean jj_3_197() { + if (jj_scan_token(USING)) return true; + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_1112() { + if (jj_scan_token(ROUTINE)) return true; + return false; + } + + final private boolean jj_3_1111() { + if (jj_scan_token(REVOKE)) return true; + return false; + } + + final private boolean jj_3_1110() { + if (jj_scan_token(RESULT)) return true; + return false; + } + + final private boolean jj_3_1109() { + if (jj_scan_token(REPLACE)) return true; + return false; + } + + final private boolean jj_3_1108() { + if (jj_scan_token(REGR_SYY)) return true; + return false; + } + + final private boolean jj_3_1107() { + if (jj_scan_token(REGR_SLOPE)) return true; + return false; + } + + final private boolean jj_3_1106() { + if (jj_scan_token(REGR_COUNT)) return true; + return false; + } + + final private boolean jj_3_1105() { + if (jj_scan_token(REFERENCING)) return true; + return false; + } + + final private boolean jj_3_1104() { + if (jj_scan_token(RECURSIVE)) return true; + return false; + } + + final private boolean jj_3_1103() { + if (jj_scan_token(READ)) return true; + return false; + } + + final private boolean jj_3_1102() { + if (jj_scan_token(PUBLIC)) return true; + return false; + } + + final private boolean jj_3_196() { + if (jj_scan_token(ON)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_1101() { + if (jj_scan_token(PRIOR)) return true; + return false; + } + + final private boolean jj_3_1100() { + if (jj_scan_token(PREPARE)) return true; + return false; + } + + final private boolean jj_3_1099() { + if (jj_scan_token(POWER)) return true; + return false; + } + + final private boolean jj_3_1098() { + if (jj_scan_token(PORTION)) return true; + return false; + } + + final private boolean jj_3_1097() { + if (jj_scan_token(PERCENT_RANK)) return true; + return false; + } + + final private boolean jj_3_573() { + if (jj_3R_213()) return true; + return false; + } + + final private boolean jj_3_1096() { + if (jj_scan_token(PERCENT)) return true; + return false; + } + + final private boolean jj_3_1095() { + if (jj_scan_token(PARTIAL)) return true; + return false; + } + + final private boolean jj_3_1094() { + if (jj_scan_token(OVERLAY)) return true; + return false; + } + + final private boolean jj_3_1093() { + if (jj_scan_token(OUT)) return true; + return false; + } + + final private boolean jj_3_1092() { + if (jj_scan_token(OPTION)) return true; + return false; + } + + final private boolean jj_3_1091() { + if (jj_scan_token(ONE)) return true; + return false; + } + + final private boolean jj_3_1090() { + if (jj_scan_token(OF)) return true; + return false; + } + + final private boolean jj_3_189() { + if (jj_scan_token(OUTER)) return true; + return false; + } + + final private boolean jj_3_1089() { + if (jj_scan_token(OBJECT)) return true; + return false; + } + + final private boolean jj_3_188() { + if (jj_scan_token(OUTER)) return true; + return false; + } + + final private boolean jj_3_565() { + if (jj_scan_token(UESCAPE)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_1088() { + if (jj_scan_token(NTILE)) return true; + return false; + } + + final private boolean jj_3_1087() { + if (jj_scan_token(NORMALIZE)) return true; + return false; + } + + final private boolean jj_3_1086() { + if (jj_scan_token(NCLOB)) return true; + return false; + } + + final private boolean jj_3_187() { + if (jj_scan_token(OUTER)) return true; + return false; + } + + final private boolean jj_3_1085() { + if (jj_scan_token(NAMES)) return true; + return false; + } + + final private boolean jj_3_1084() { + if (jj_scan_token(MONTH)) return true; + return false; + } + + final private boolean jj_3_1083() { + if (jj_scan_token(MOD)) return true; + return false; + } + + final private boolean jj_3_195() { + if (jj_scan_token(CROSS)) return true; + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1082() { + if (jj_scan_token(METHOD)) return true; + return false; + } + + final private boolean jj_3_1081() { + if (jj_scan_token(MAX)) return true; + return false; + } + + final private boolean jj_3_194() { + if (jj_scan_token(FULL)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_189()) jj_scanpos = xsp; + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1080() { + if (jj_scan_token(MATCH)) return true; + return false; + } + + final private boolean jj_3_1079() { + if (jj_scan_token(LOWER)) return true; + return false; + } + + final private boolean jj_3_193() { + if (jj_scan_token(RIGHT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_188()) jj_scanpos = xsp; + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1078() { + if (jj_scan_token(LOCALTIME)) return true; + return false; + } + + final private boolean jj_3_572() { + if (jj_scan_token(UNICODE_QUOTED_IDENTIFIER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_565()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_1077() { + if (jj_scan_token(LIKE_REGEX)) return true; + return false; + } + + final private boolean jj_3_192() { + if (jj_scan_token(LEFT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_187()) jj_scanpos = xsp; + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1076() { + if (jj_scan_token(LENGTH)) return true; + return false; + } + + final private boolean jj_3_1075() { + if (jj_scan_token(LAST_VALUE)) return true; + return false; + } + + final private boolean jj_3_191() { + if (jj_scan_token(INNER)) return true; + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1074() { + if (jj_scan_token(LANGUAGE)) return true; + return false; + } + + final private boolean jj_3_1073() { + if (jj_scan_token(K)) return true; + return false; + } + + final private boolean jj_3_1072() { + if (jj_scan_token(JSON_OBJECTAGG)) return true; + return false; + } + + final private boolean jj_3_571() { + if (jj_scan_token(BRACKET_QUOTED_IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1071() { + if (jj_scan_token(JSON_ARRAYAGG)) return true; + return false; + } + + final private boolean jj_3_1070() { + if (jj_scan_token(IS)) return true; + return false; + } + + final private boolean jj_3_1069() { + if (jj_scan_token(INT)) return true; + return false; + } + + final private boolean jj_3_1068() { + if (jj_scan_token(INOUT)) return true; + return false; + } + + final private boolean jj_3_190() { + if (jj_scan_token(JOIN)) return true; + return false; + } + + final private boolean jj_3_1067() { + if (jj_scan_token(INDICATOR)) return true; + return false; + } + + final private boolean jj_3R_126() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_190()) { + jj_scanpos = xsp; + if (jj_3_191()) { + jj_scanpos = xsp; + if (jj_3_192()) { + jj_scanpos = xsp; + if (jj_3_193()) { + jj_scanpos = xsp; + if (jj_3_194()) { + jj_scanpos = xsp; + if (jj_3_195()) return true; + } + } + } + } + } + return false; + } + + final private boolean jj_3_1066() { + if (jj_scan_token(IMMEDIATE)) return true; + return false; + } + + final private boolean jj_3_570() { + if (jj_scan_token(BIG_QUERY_BACK_QUOTED_IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1065() { + if (jj_scan_token(HOLD)) return true; + return false; + } + + final private boolean jj_3_1064() { + if (jj_scan_token(GO)) return true; + return false; + } + + final private boolean jj_3_1063() { + if (jj_scan_token(GENERAL)) return true; + return false; + } + + final private boolean jj_3_1062() { + if (jj_scan_token(FUNCTION)) return true; + return false; + } + + final private boolean jj_3_1061() { + if (jj_scan_token(FOUND)) return true; + return false; + } + + final private boolean jj_3_1060() { + if (jj_scan_token(FLOOR)) return true; + return false; + } + + final private boolean jj_3_569() { + if (jj_scan_token(BACK_QUOTED_IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1059() { + if (jj_scan_token(FIRST)) return true; + return false; + } + + final private boolean jj_3R_285() { + return false; + } + + final private boolean jj_3_1058() { + if (jj_scan_token(EXTRACT)) return true; + return false; + } + + final private boolean jj_3_1057() { + if (jj_scan_token(EXP)) return true; + return false; + } + + final private boolean jj_3R_125() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_186()) { + jj_scanpos = xsp; + if (jj_3R_285()) return true; + } + return false; + } + + final private boolean jj_3_186() { + if (jj_scan_token(NATURAL)) return true; + return false; + } + + final private boolean jj_3_1056() { + if (jj_scan_token(EXEC)) return true; + return false; + } + + final private boolean jj_3_1055() { + if (jj_scan_token(ESCAPE)) return true; + return false; + } + + final private boolean jj_3_1054() { + if (jj_scan_token(END_FRAME)) return true; + return false; + } + + final private boolean jj_3_568() { + if (jj_scan_token(QUOTED_IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1053() { + if (jj_scan_token(ELSE)) return true; + return false; + } + + final private boolean jj_3_1052() { + if (jj_scan_token(DYNAMIC)) return true; + return false; + } + + final private boolean jj_3_1051() { + if (jj_scan_token(DISCONNECT)) return true; + return false; + } + + final private boolean jj_3_1050() { + if (jj_scan_token(DETERMINISTIC)) return true; + return false; + } + + final private boolean jj_3_1049() { + if (jj_scan_token(DEREF)) return true; + return false; + } + + final private boolean jj_3_567() { + if (jj_scan_token(HYPHENATED_IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1048() { + if (jj_scan_token(DEFERRED)) return true; + return false; + } + + final private boolean jj_3_185() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_1047() { + if (jj_scan_token(DECIMAL)) return true; + return false; + } + + final private boolean jj_3_1046() { + if (jj_scan_token(DAY)) return true; + return false; + } + + final private boolean jj_3_1045() { + if (jj_scan_token(CYCLE)) return true; + return false; + } + + final private boolean jj_3_1044() { + if (jj_scan_token(CURRENT_TIMESTAMP)) return true; + return false; + } + + final private boolean jj_3R_283() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_184()) { + jj_scanpos = xsp; + if (jj_3_185()) return true; + } + return false; + } + + final private boolean jj_3_184() { + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_566() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + final private boolean jj_3_1043() { + if (jj_scan_token(CURRENT_ROW)) return true; + return false; + } + + final private boolean jj_3_1042() { + if (jj_scan_token(CURRENT_DEFAULT_TRANSFORM_GROUP)) return true; + return false; + } + + final private boolean jj_3_1041() { + if (jj_scan_token(CUME_DIST)) return true; + return false; + } + + final private boolean jj_3_1040() { + if (jj_scan_token(COVAR_POP)) return true; + return false; + } + + final private boolean jj_3_1039() { + if (jj_scan_token(CORR)) return true; + return false; + } + + final private boolean jj_3R_214() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_566()) { + jj_scanpos = xsp; + if (jj_3_567()) { + jj_scanpos = xsp; + if (jj_3_568()) { + jj_scanpos = xsp; + if (jj_3_569()) { + jj_scanpos = xsp; + if (jj_3_570()) { + jj_scanpos = xsp; + if (jj_3_571()) { + jj_scanpos = xsp; + if (jj_3_572()) { + jj_scanpos = xsp; + if (jj_3_573()) return true; + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_1038() { + if (jj_scan_token(CONTAINS)) return true; + return false; + } + + final private boolean jj_3_1037() { + if (jj_scan_token(CONNECTION)) return true; + return false; + } + + final private boolean jj_3_1036() { + if (jj_scan_token(COMMIT)) return true; + return false; + } + + final private boolean jj_3_1035() { + if (jj_scan_token(COLLATION)) return true; + return false; + } + + final private boolean jj_3_1034() { + if (jj_scan_token(CLOSE)) return true; + return false; + } + + final private boolean jj_3_1033() { + if (jj_scan_token(CHECK)) return true; + return false; + } + + final private boolean jj_3_1032() { + if (jj_scan_token(CHARACTER)) return true; + return false; + } + + final private boolean jj_3R_124() { + if (jj_3R_284()) return true; + return false; + } + + final private boolean jj_3_1031() { + if (jj_scan_token(CEIL)) return true; + return false; + } + + final private boolean jj_3_1030() { + if (jj_scan_token(CASCADED)) return true; + return false; + } + + final private boolean jj_3_1029() { + if (jj_scan_token(CALLED)) return true; + return false; + } + + final private boolean jj_3_1028() { + if (jj_scan_token(BREADTH)) return true; + return false; + } + + final private boolean jj_3_182() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_1027() { + if (jj_scan_token(BLOB)) return true; + return false; + } + + final private boolean jj_3_1026() { + if (jj_scan_token(BIGINT)) return true; + return false; + } + + final private boolean jj_3_1025() { + if (jj_scan_token(BEGIN_FRAME)) return true; + return false; + } + + final private boolean jj_3_1024() { + if (jj_scan_token(AVG)) return true; + return false; + } + + final private boolean jj_3_181() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_1023() { + if (jj_scan_token(AT)) return true; + return false; + } + + final private boolean jj_3_1022() { + if (jj_scan_token(ASENSITIVE)) return true; + return false; + } + + final private boolean jj_3_183() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_181()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_182()) { + jj_scanpos = xsp; + if (jj_3R_124()) return true; + } + return false; + } + + final private boolean jj_3_1021() { + if (jj_scan_token(ARRAY_MAX_CARDINALITY)) return true; + return false; + } + + final private boolean jj_3_1020() { + if (jj_scan_token(AND)) return true; + return false; + } + + final private boolean jj_3_1019() { + if (jj_scan_token(ALLOCATE)) return true; + return false; + } + + final private boolean jj_3R_173() { + if (jj_scan_token(HOOK)) return true; + return false; + } + + final private boolean jj_3_1018() { + if (jj_scan_token(ACTION)) return true; + return false; + } + + final private boolean jj_3_1017() { + if (jj_scan_token(A)) return true; + return false; + } + + final private boolean jj_3_1016() { + if (jj_scan_token(ASYNC)) return true; + return false; + } + + final private boolean jj_3R_123() { + if (jj_3R_283()) return true; + return false; + } + + final private boolean jj_3_1015() { + if (jj_scan_token(CONTINUOUS)) return true; + return false; + } + + final private boolean jj_3_1014() { + if (jj_scan_token(PASSWORD)) return true; + return false; + } + + final private boolean jj_3_1013() { + if (jj_scan_token(INLINE_SIZE)) return true; + return false; + } + + final private boolean jj_3_1012() { + if (jj_scan_token(VALUE_TYPE)) return true; + return false; + } + + final private boolean jj_3_1011() { + if (jj_scan_token(CACHE_GROUP)) return true; + return false; + } + + final private boolean jj_3_1010() { + if (jj_scan_token(AFFINITY_KEY)) return true; + return false; + } + + final private boolean jj_3_1009() { + if (jj_scan_token(SEMI)) return true; + return false; + } + + final private boolean jj_3_564() { + if (jj_scan_token(SQL_TSI_YEAR)) return true; + return false; + } + + final private boolean jj_3_563() { + if (jj_scan_token(YEAR)) return true; + return false; + } + + final private boolean jj_3R_267() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_1009()) { + jj_scanpos = xsp; + if (jj_3_1010()) { + jj_scanpos = xsp; + if (jj_3_1011()) { + jj_scanpos = xsp; + if (jj_3_1012()) { + jj_scanpos = xsp; + if (jj_3_1013()) { + jj_scanpos = xsp; + if (jj_3_1014()) { + jj_scanpos = xsp; + if (jj_3_1015()) { + jj_scanpos = xsp; + if (jj_3_1016()) { + jj_scanpos = xsp; + if (jj_3_1017()) { + jj_scanpos = xsp; + if (jj_3_1018()) { + jj_scanpos = xsp; + if (jj_3_1019()) { + jj_scanpos = xsp; + if (jj_3_1020()) { + jj_scanpos = xsp; + if (jj_3_1021()) { + jj_scanpos = xsp; + if (jj_3_1022()) { + jj_scanpos = xsp; + if (jj_3_1023()) { + jj_scanpos = xsp; + if (jj_3_1024()) { + jj_scanpos = xsp; + if (jj_3_1025()) { + jj_scanpos = xsp; + if (jj_3_1026()) { + jj_scanpos = xsp; + if (jj_3_1027()) { + jj_scanpos = xsp; + if (jj_3_1028()) { + jj_scanpos = xsp; + if (jj_3_1029()) { + jj_scanpos = xsp; + if (jj_3_1030()) { + jj_scanpos = xsp; + if (jj_3_1031()) { + jj_scanpos = xsp; + if (jj_3_1032()) { + jj_scanpos = xsp; + if (jj_3_1033()) { + jj_scanpos = xsp; + if (jj_3_1034()) { + jj_scanpos = xsp; + if (jj_3_1035()) { + jj_scanpos = xsp; + if (jj_3_1036()) { + jj_scanpos = xsp; + if (jj_3_1037()) { + jj_scanpos = xsp; + if (jj_3_1038()) { + jj_scanpos = xsp; + if (jj_3_1039()) { + jj_scanpos = xsp; + if (jj_3_1040()) { + jj_scanpos = xsp; + if (jj_3_1041()) { + jj_scanpos = xsp; + if (jj_3_1042()) { + jj_scanpos = xsp; + if (jj_3_1043()) { + jj_scanpos = xsp; + if (jj_3_1044()) { + jj_scanpos = xsp; + if (jj_3_1045()) { + jj_scanpos = xsp; + if (jj_3_1046()) { + jj_scanpos = xsp; + if (jj_3_1047()) { + jj_scanpos = xsp; + if (jj_3_1048()) { + jj_scanpos = xsp; + if (jj_3_1049()) { + jj_scanpos = xsp; + if (jj_3_1050()) { + jj_scanpos = xsp; + if (jj_3_1051()) { + jj_scanpos = xsp; + if (jj_3_1052()) { + jj_scanpos = xsp; + if (jj_3_1053()) { + jj_scanpos = xsp; + if (jj_3_1054()) { + jj_scanpos = xsp; + if (jj_3_1055()) { + jj_scanpos = xsp; + if (jj_3_1056()) { + jj_scanpos = xsp; + if (jj_3_1057()) { + jj_scanpos = xsp; + if (jj_3_1058()) { + jj_scanpos = xsp; + if (jj_3_1059()) { + jj_scanpos = xsp; + if (jj_3_1060()) { + jj_scanpos = xsp; + if (jj_3_1061()) { + jj_scanpos = xsp; + if (jj_3_1062()) { + jj_scanpos = xsp; + if (jj_3_1063()) { + jj_scanpos = xsp; + if (jj_3_1064()) { + jj_scanpos = xsp; + if (jj_3_1065()) { + jj_scanpos = xsp; + if (jj_3_1066()) { + jj_scanpos = xsp; + if (jj_3_1067()) { + jj_scanpos = xsp; + if (jj_3_1068()) { + jj_scanpos = xsp; + if (jj_3_1069()) { + jj_scanpos = xsp; + if (jj_3_1070()) { + jj_scanpos = xsp; + if (jj_3_1071()) { + jj_scanpos = xsp; + if (jj_3_1072()) { + jj_scanpos = xsp; + if (jj_3_1073()) { + jj_scanpos = xsp; + if (jj_3_1074()) { + jj_scanpos = xsp; + if (jj_3_1075()) { + jj_scanpos = xsp; + if (jj_3_1076()) { + jj_scanpos = xsp; + if (jj_3_1077()) { + jj_scanpos = xsp; + if (jj_3_1078()) { + jj_scanpos = xsp; + if (jj_3_1079()) { + jj_scanpos = xsp; + if (jj_3_1080()) { + jj_scanpos = xsp; + if (jj_3_1081()) { + jj_scanpos = xsp; + if (jj_3_1082()) { + jj_scanpos = xsp; + if (jj_3_1083()) { + jj_scanpos = xsp; + if (jj_3_1084()) { + jj_scanpos = xsp; + if (jj_3_1085()) { + jj_scanpos = xsp; + if (jj_3_1086()) { + jj_scanpos = xsp; + if (jj_3_1087()) { + jj_scanpos = xsp; + if (jj_3_1088()) { + jj_scanpos = xsp; + if (jj_3_1089()) { + jj_scanpos = xsp; + if (jj_3_1090()) { + jj_scanpos = xsp; + if (jj_3_1091()) { + jj_scanpos = xsp; + if (jj_3_1092()) { + jj_scanpos = xsp; + if (jj_3_1093()) { + jj_scanpos = xsp; + if (jj_3_1094()) { + jj_scanpos = xsp; + if (jj_3_1095()) { + jj_scanpos = xsp; + if (jj_3_1096()) { + jj_scanpos = xsp; + if (jj_3_1097()) { + jj_scanpos = xsp; + if (jj_3_1098()) { + jj_scanpos = xsp; + if (jj_3_1099()) { + jj_scanpos = xsp; + if (jj_3_1100()) { + jj_scanpos = xsp; + if (jj_3_1101()) { + jj_scanpos = xsp; + if (jj_3_1102()) { + jj_scanpos = xsp; + if (jj_3_1103()) { + jj_scanpos = xsp; + if (jj_3_1104()) { + jj_scanpos = xsp; + if (jj_3_1105()) { + jj_scanpos = xsp; + if (jj_3_1106()) { + jj_scanpos = xsp; + if (jj_3_1107()) { + jj_scanpos = xsp; + if (jj_3_1108()) { + jj_scanpos = xsp; + if (jj_3_1109()) { + jj_scanpos = xsp; + if (jj_3_1110()) { + jj_scanpos = xsp; + if (jj_3_1111()) { + jj_scanpos = xsp; + if (jj_3_1112()) { + jj_scanpos = xsp; + if (jj_3_1113()) { + jj_scanpos = xsp; + if (jj_3_1114()) { + jj_scanpos = xsp; + if (jj_3_1115()) { + jj_scanpos = xsp; + if (jj_3_1116()) { + jj_scanpos = xsp; + if (jj_3_1117()) { + jj_scanpos = xsp; + if (jj_3_1118()) { + jj_scanpos = xsp; + if (jj_3_1119()) { + jj_scanpos = xsp; + if (jj_3_1120()) { + jj_scanpos = xsp; + if (jj_3_1121()) { + jj_scanpos = xsp; + if (jj_3_1122()) { + jj_scanpos = xsp; + if (jj_3_1123()) { + jj_scanpos = xsp; + if (jj_3_1124()) { + jj_scanpos = xsp; + if (jj_3_1125()) { + jj_scanpos = xsp; + if (jj_3_1126()) { + jj_scanpos = xsp; + if (jj_3_1127()) { + jj_scanpos = xsp; + if (jj_3_1128()) { + jj_scanpos = xsp; + if (jj_3_1129()) { + jj_scanpos = xsp; + if (jj_3_1130()) { + jj_scanpos = xsp; + if (jj_3_1131()) { + jj_scanpos = xsp; + if (jj_3_1132()) { + jj_scanpos = xsp; + if (jj_3_1133()) { + jj_scanpos = xsp; + if (jj_3_1134()) { + jj_scanpos = xsp; + if (jj_3_1135()) { + jj_scanpos = xsp; + if (jj_3_1136()) { + jj_scanpos = xsp; + if (jj_3_1137()) { + jj_scanpos = xsp; + if (jj_3_1138()) { + jj_scanpos = xsp; + if (jj_3_1139()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_562() { + if (jj_scan_token(SQL_TSI_QUARTER)) return true; + return false; + } + + final private boolean jj_3_561() { + if (jj_scan_token(QUARTER)) return true; + return false; + } + + final private boolean jj_3_560() { + if (jj_scan_token(SQL_TSI_MONTH)) return true; + return false; + } + + final private boolean jj_3_180() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_123()) return true; + return false; + } + + final private boolean jj_3_559() { + if (jj_scan_token(MONTH)) return true; + return false; + } + + final private boolean jj_3_558() { + if (jj_scan_token(SQL_TSI_WEEK)) return true; + return false; + } + + final private boolean jj_3_557() { + if (jj_scan_token(WEEK)) return true; + return false; + } + + final private boolean jj_3_556() { + if (jj_scan_token(SQL_TSI_DAY)) return true; + return false; + } + + final private boolean jj_3_555() { + if (jj_scan_token(DAY)) return true; + return false; + } + + final private boolean jj_3_554() { + if (jj_scan_token(SQL_TSI_HOUR)) return true; + return false; + } + + final private boolean jj_3_1008() { + if (jj_3R_269()) return true; + return false; + } + + final private boolean jj_3_553() { + if (jj_scan_token(HOUR)) return true; + return false; + } + + final private boolean jj_3_1007() { + if (jj_3R_268()) return true; + return false; + } + + final private boolean jj_3_552() { + if (jj_scan_token(SQL_TSI_MINUTE)) return true; + return false; + } + + final private boolean jj_3_1006() { + if (jj_3R_267()) return true; + return false; + } + + final private boolean jj_3_551() { + if (jj_scan_token(MINUTE)) return true; + return false; + } + + final private boolean jj_3_550() { + if (jj_scan_token(SQL_TSI_SECOND)) return true; + return false; + } + + final private boolean jj_3_549() { + if (jj_scan_token(SECOND)) return true; + return false; + } + + final private boolean jj_3_548() { + if (jj_scan_token(SQL_TSI_MICROSECOND)) return true; + return false; + } + + final private boolean jj_3R_213() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_1006()) { + jj_scanpos = xsp; + if (jj_3_1007()) { + jj_scanpos = xsp; + if (jj_3_1008()) return true; + } + } + return false; + } + + final private boolean jj_3_547() { + if (jj_scan_token(SQL_TSI_FRAC_SECOND)) return true; + return false; + } + + final private boolean jj_3_546() { + if (jj_scan_token(NANOSECOND)) return true; + return false; + } + + final private boolean jj_3_545() { + if (jj_scan_token(MICROSECOND)) return true; + return false; + } + + final private boolean jj_3R_309() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_544()) { + jj_scanpos = xsp; + if (jj_3_545()) { + jj_scanpos = xsp; + if (jj_3_546()) { + jj_scanpos = xsp; + if (jj_3_547()) { + jj_scanpos = xsp; + if (jj_3_548()) { + jj_scanpos = xsp; + if (jj_3_549()) { + jj_scanpos = xsp; + if (jj_3_550()) { + jj_scanpos = xsp; + if (jj_3_551()) { + jj_scanpos = xsp; + if (jj_3_552()) { + jj_scanpos = xsp; + if (jj_3_553()) { + jj_scanpos = xsp; + if (jj_3_554()) { + jj_scanpos = xsp; + if (jj_3_555()) { + jj_scanpos = xsp; + if (jj_3_556()) { + jj_scanpos = xsp; + if (jj_3_557()) { + jj_scanpos = xsp; + if (jj_3_558()) { + jj_scanpos = xsp; + if (jj_3_559()) { + jj_scanpos = xsp; + if (jj_3_560()) { + jj_scanpos = xsp; + if (jj_3_561()) { + jj_scanpos = xsp; + if (jj_3_562()) { + jj_scanpos = xsp; + if (jj_3_563()) { + jj_scanpos = xsp; + if (jj_3_564()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_544() { + if (jj_scan_token(FRAC_SECOND)) return true; + return false; + } + + final private boolean jj_3_543() { + if (jj_scan_token(MILLENNIUM)) return true; + return false; + } + + final private boolean jj_3_542() { + if (jj_scan_token(CENTURY)) return true; + return false; + } + + final private boolean jj_3_541() { + if (jj_scan_token(DECADE)) return true; + return false; + } + + final private boolean jj_3_540() { + if (jj_scan_token(EPOCH)) return true; + return false; + } + + final private boolean jj_3_539() { + if (jj_scan_token(YEAR)) return true; + return false; + } + + final private boolean jj_3_538() { + if (jj_scan_token(QUARTER)) return true; + return false; + } + + final private boolean jj_3_179() { + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_537() { + if (jj_scan_token(MONTH)) return true; + return false; + } + + final private boolean jj_3_536() { + if (jj_scan_token(WEEK)) return true; + return false; + } + + final private boolean jj_3_535() { + if (jj_scan_token(ISOYEAR)) return true; + return false; + } + + final private boolean jj_3_178() { + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_534() { + if (jj_scan_token(ISODOW)) return true; + return false; + } + + final private boolean jj_3_177() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_533() { + if (jj_scan_token(DOY)) return true; + return false; + } + + final private boolean jj_3_532() { + if (jj_scan_token(DOW)) return true; + return false; + } + + final private boolean jj_3_531() { + if (jj_scan_token(DAY)) return true; + return false; + } + + final private boolean jj_3_530() { + if (jj_scan_token(HOUR)) return true; + return false; + } + + final private boolean jj_3_529() { + if (jj_scan_token(MINUTE)) return true; + return false; + } + + final private boolean jj_3_528() { + if (jj_scan_token(SECOND)) return true; + return false; + } + + final private boolean jj_3R_228() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_527()) { + jj_scanpos = xsp; + if (jj_3_528()) { + jj_scanpos = xsp; + if (jj_3_529()) { + jj_scanpos = xsp; + if (jj_3_530()) { + jj_scanpos = xsp; + if (jj_3_531()) { + jj_scanpos = xsp; + if (jj_3_532()) { + jj_scanpos = xsp; + if (jj_3_533()) { + jj_scanpos = xsp; + if (jj_3_534()) { + jj_scanpos = xsp; + if (jj_3_535()) { + jj_scanpos = xsp; + if (jj_3_536()) { + jj_scanpos = xsp; + if (jj_3_537()) { + jj_scanpos = xsp; + if (jj_3_538()) { + jj_scanpos = xsp; + if (jj_3_539()) { + jj_scanpos = xsp; + if (jj_3_540()) { + jj_scanpos = xsp; + if (jj_3_541()) { + jj_scanpos = xsp; + if (jj_3_542()) { + jj_scanpos = xsp; + if (jj_3_543()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_527() { + if (jj_scan_token(MILLISECOND)) return true; + return false; + } + + final private boolean jj_3R_121() { + if (jj_scan_token(WHEN)) return true; + if (jj_scan_token(NOT)) return true; + return false; + } + + final private boolean jj_3_523() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_524() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_526() { + if (jj_3R_208()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_524()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_522() { + if (jj_3R_207()) return true; + return false; + } + + final private boolean jj_3_521() { + if (jj_3R_206()) return true; + return false; + } + + final private boolean jj_3_520() { + if (jj_3R_212()) return true; + return false; + } + + final private boolean jj_3_519() { + if (jj_3R_205()) return true; + return false; + } + + final private boolean jj_3_518() { + if (jj_3R_211()) return true; + return false; + } + + final private boolean jj_3_176() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_525() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_518()) { + jj_scanpos = xsp; + if (jj_3_519()) { + jj_scanpos = xsp; + if (jj_3_520()) { + jj_scanpos = xsp; + if (jj_3_521()) { + jj_scanpos = xsp; + if (jj_3_522()) return true; + } + } + } + } + if (jj_3R_209()) return true; + return false; + } + + final private boolean jj_3R_204() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_525()) { + jj_scanpos = xsp; + if (jj_3_526()) return true; + } + return false; + } + + final private boolean jj_3R_122() { + if (jj_scan_token(WHEN)) return true; + if (jj_scan_token(MATCHED)) return true; + return false; + } + + final private boolean jj_3_510() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_511() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_508() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_517() { + if (jj_3R_208()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_511()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_509() { + if (jj_scan_token(TO)) return true; + if (jj_3R_208()) return true; + return false; + } + + final private boolean jj_3_504() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3_173() { + if (jj_3R_121()) return true; + return false; + } + + final private boolean jj_3_175() { + if (jj_3R_121()) return true; + return false; + } + + final private boolean jj_3_506() { + if (jj_3R_208()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_504()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_505() { + if (jj_3R_207()) return true; + return false; + } + + final private boolean jj_3_174() { + if (jj_3R_122()) return true; + return false; + } + + final private boolean jj_3_516() { + if (jj_3R_207()) return true; + if (jj_3R_209()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_509()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_171() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_507() { + if (jj_scan_token(TO)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_505()) { + jj_scanpos = xsp; + if (jj_3_506()) return true; + } + return false; + } + + final private boolean jj_3_172() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_171()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_169() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_502() { + if (jj_3R_208()) return true; + if (jj_3R_209()) return true; + return false; + } + + final private boolean jj_3_170() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_169()) jj_scanpos = xsp; + if (jj_3R_119()) return true; + return false; + } + + final private boolean jj_3_501() { + if (jj_3R_207()) return true; + return false; + } + + final private boolean jj_3_515() { + if (jj_3R_206()) return true; + if (jj_3R_209()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_507()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_500() { + if (jj_3R_206()) return true; + return false; + } + + final private boolean jj_3R_87() { + if (jj_scan_token(MERGE)) return true; + if (jj_scan_token(INTO)) return true; + return false; + } + + final private boolean jj_3_503() { + if (jj_scan_token(TO)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_500()) { + jj_scanpos = xsp; + if (jj_3_501()) { + jj_scanpos = xsp; + if (jj_3_502()) return true; + } + } + return false; + } + + final private boolean jj_3_514() { + if (jj_3R_212()) return true; + if (jj_3R_209()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_503()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_499() { + if (jj_scan_token(TO)) return true; + if (jj_3R_205()) return true; + return false; + } + + final private boolean jj_3_513() { + if (jj_3R_205()) return true; + if (jj_3R_209()) return true; + return false; + } + + final private boolean jj_3_512() { + if (jj_3R_211()) return true; + if (jj_3R_209()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_499()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3R_170() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_512()) { + jj_scanpos = xsp; + if (jj_3_513()) { + jj_scanpos = xsp; + if (jj_3_514()) { + jj_scanpos = xsp; + if (jj_3_515()) { + jj_scanpos = xsp; + if (jj_3_516()) { + jj_scanpos = xsp; + if (jj_3_517()) return true; + } + } + } + } + } + return false; + } + + final private boolean jj_3_168() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_498() { + if (jj_scan_token(SECONDS)) return true; + return false; + } + + final private boolean jj_3R_208() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_497()) { + jj_scanpos = xsp; + if (jj_3_498()) return true; + } + return false; + } + + final private boolean jj_3_497() { + if (jj_scan_token(SECOND)) return true; + return false; + } + + final private boolean jj_3_166() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_167() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_166()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_164() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_496() { + if (jj_scan_token(MINUTES)) return true; + return false; + } + + final private boolean jj_3R_207() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_495()) { + jj_scanpos = xsp; + if (jj_3_496()) return true; + } + return false; + } + + final private boolean jj_3_165() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_164()) jj_scanpos = xsp; + if (jj_3R_119()) return true; + return false; + } + + final private boolean jj_3_495() { + if (jj_scan_token(MINUTE)) return true; + return false; + } + + final private boolean jj_3_494() { + if (jj_scan_token(HOURS)) return true; + return false; + } + + final private boolean jj_3R_206() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_493()) { + jj_scanpos = xsp; + if (jj_3_494()) return true; + } + return false; + } + + final private boolean jj_3_493() { + if (jj_scan_token(HOUR)) return true; + return false; + } + + final private boolean jj_3R_86() { + if (jj_scan_token(UPDATE)) return true; + if (jj_3R_130()) return true; + return false; + } + + final private boolean jj_3_492() { + if (jj_scan_token(DAYS)) return true; + return false; + } + + final private boolean jj_3R_212() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_491()) { + jj_scanpos = xsp; + if (jj_3_492()) return true; + } + return false; + } + + final private boolean jj_3_491() { + if (jj_scan_token(DAY)) return true; + return false; + } + + final private boolean jj_3_490() { + if (jj_scan_token(MONTHS)) return true; + return false; + } + + final private boolean jj_3R_205() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_489()) { + jj_scanpos = xsp; + if (jj_3_490()) return true; + } + return false; + } + + final private boolean jj_3_489() { + if (jj_scan_token(MONTH)) return true; + return false; + } + + final private boolean jj_3_162() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_163() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_162()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_160() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_488() { + if (jj_scan_token(YEARS)) return true; + return false; + } + + final private boolean jj_3_161() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_160()) jj_scanpos = xsp; + if (jj_3R_119()) return true; + return false; + } + + final private boolean jj_3R_211() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_487()) { + jj_scanpos = xsp; + if (jj_3_488()) return true; + } + return false; + } + + final private boolean jj_3_487() { + if (jj_scan_token(YEAR)) return true; + return false; + } + + final private boolean jj_3R_85() { + if (jj_scan_token(DELETE)) return true; + if (jj_scan_token(FROM)) return true; + return false; + } + + final private boolean jj_3_484() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_483() { + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_482() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_486() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_482()) { + jj_scanpos = xsp; + if (jj_3_483()) { + jj_scanpos = xsp; + if (jj_3_484()) return true; + } + } + if (jj_3R_204()) return true; + return false; + } + + final private boolean jj_3_485() { + if (jj_scan_token(QUOTED_STRING)) return true; + if (jj_3R_170()) return true; + return false; + } + + final private boolean jj_3_480() { + if (jj_scan_token(PLUS)) return true; + return false; + } + + final private boolean jj_3_481() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_479()) { + jj_scanpos = xsp; + if (jj_3_480()) return true; + } + return false; + } + + final private boolean jj_3_479() { + if (jj_scan_token(MINUS)) return true; + return false; + } + + final private boolean jj_3R_198() { + if (jj_scan_token(INTERVAL)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_481()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_485()) { + jj_scanpos = xsp; + if (jj_3_486()) return true; + } + return false; + } + + final private boolean jj_3_159() { + if (jj_3R_120()) return true; + return false; + } + + final private boolean jj_3_157() { + if (jj_scan_token(EXTEND)) return true; + return false; + } + + final private boolean jj_3_158() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_157()) jj_scanpos = xsp; + if (jj_3R_119()) return true; + return false; + } + + final private boolean jj_3_156() { + if (jj_scan_token(UPSERT)) return true; + return false; + } + + final private boolean jj_3_477() { + if (jj_scan_token(PLUS)) return true; + return false; + } + + final private boolean jj_3_155() { + if (jj_scan_token(INSERT)) return true; + return false; + } + + final private boolean jj_3_478() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_476()) { + jj_scanpos = xsp; + if (jj_3_477()) return true; + } + return false; + } + + final private boolean jj_3_476() { + if (jj_scan_token(MINUS)) return true; + return false; + } + + final private boolean jj_3R_84() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_155()) { + jj_scanpos = xsp; + if (jj_3_156()) return true; + } + if (jj_3R_275()) return true; + return false; + } + + final private boolean jj_3R_149() { + if (jj_scan_token(INTERVAL)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_478()) jj_scanpos = xsp; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_153() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_65()) return true; + return false; + } + + final private boolean jj_3R_182() { + if (jj_scan_token(PERIOD)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_154() { + if (jj_3R_118()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_153()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3R_203() { + return false; + } + + final private boolean jj_3_474() { + if (jj_3R_188()) return true; + return false; + } + + final private boolean jj_3R_276() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_475() { + if (jj_scan_token(LBRACKET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_474()) { + jj_scanpos = xsp; + if (jj_3R_203()) return true; + } + return false; + } + + final private boolean jj_3R_299() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_201()) return true; + return false; + } + + final private boolean jj_3R_88() { + if (jj_scan_token(CALL)) return true; + if (jj_3R_276()) return true; + return false; + } + + final private boolean jj_3R_181() { + if (jj_scan_token(MAP)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_299()) { + jj_scanpos = xsp; + if (jj_3_475()) return true; + } + return false; + } + + final private boolean jj_3R_202() { + return false; + } + + final private boolean jj_3_147() { + if (jj_scan_token(SCHEMA)) return true; + return false; + } + + final private boolean jj_3_472() { + if (jj_3R_188()) return true; + return false; + } + + final private boolean jj_3_473() { + if (jj_scan_token(LBRACKET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_472()) { + jj_scanpos = xsp; + if (jj_3R_202()) return true; + } + return false; + } + + final private boolean jj_3_152() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(580)) jj_scanpos = xsp; + if (jj_3R_117()) return true; + return false; + } + + final private boolean jj_3_146() { + if (jj_scan_token(CATALOG)) return true; + return false; + } + + final private boolean jj_3_149() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_151() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(600)) { + jj_scanpos = xsp; + if (jj_scan_token(781)) { + jj_scanpos = xsp; + if (jj_scan_token(780)) { + jj_scanpos = xsp; + if (jj_scan_token(777)) { + jj_scanpos = xsp; + if (jj_scan_token(778)) { + jj_scanpos = xsp; + if (jj_scan_token(779)) { + jj_scanpos = xsp; + if (jj_scan_token(776)) return true; + } + } + } + } + } + } + return false; + } + + final private boolean jj_3R_298() { + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_148() { + if (jj_scan_token(TABLE)) return true; + return false; + } + + final private boolean jj_3R_180() { + if (jj_scan_token(ARRAY)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_298()) { + jj_scanpos = xsp; + if (jj_3_473()) return true; + } + return false; + } + + final private boolean jj_3_145() { + if (jj_scan_token(DATABASE)) return true; + return false; + } + + final private boolean jj_3R_274() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_148()) jj_scanpos = xsp; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_469() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_150() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_145()) { + jj_scanpos = xsp; + if (jj_3_146()) { + jj_scanpos = xsp; + if (jj_3_147()) return true; + } + } + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_471() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_83() { + if (jj_scan_token(DESCRIBE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_150()) { + jj_scanpos = xsp; + if (jj_3R_274()) { + jj_scanpos = xsp; + if (jj_3_152()) return true; + } + } + return false; + } + + final private boolean jj_3_470() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_201()) return true; + return false; + } + + final private boolean jj_3R_179() { + if (jj_scan_token(MULTISET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_470()) { + jj_scanpos = xsp; + if (jj_3_471()) return true; + } + return false; + } + + final private boolean jj_3_142() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_144() { + if (jj_scan_token(INCLUDING)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_142()) jj_scanpos = xsp; + if (jj_scan_token(ATTRIBUTES)) return true; + return false; + } + + final private boolean jj_3_143() { + if (jj_scan_token(EXCLUDING)) return true; + if (jj_scan_token(ATTRIBUTES)) return true; + return false; + } + + final private boolean jj_3_468() { + if (jj_scan_token(TIMESTAMP)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3R_115() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_143()) { + jj_scanpos = xsp; + if (jj_3_144()) return true; + } + return false; + } + + final private boolean jj_3_467() { + if (jj_scan_token(TIME)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_466() { + if (jj_scan_token(DATE)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_465() { + if (jj_scan_token(LBRACE_TS)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_141() { + if (jj_scan_token(WITHOUT)) return true; + if (jj_scan_token(IMPLEMENTATION)) return true; + return false; + } + + final private boolean jj_3_464() { + if (jj_scan_token(LBRACE_T)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_140() { + if (jj_scan_token(WITH)) return true; + if (jj_scan_token(IMPLEMENTATION)) return true; + return false; + } + + final private boolean jj_3R_197() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_463()) { + jj_scanpos = xsp; + if (jj_3_464()) { + jj_scanpos = xsp; + if (jj_3_465()) { + jj_scanpos = xsp; + if (jj_3_466()) { + jj_scanpos = xsp; + if (jj_3_467()) { + jj_scanpos = xsp; + if (jj_3_468()) return true; + } + } + } + } + } + return false; + } + + final private boolean jj_3_463() { + if (jj_scan_token(LBRACE_D)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_139() { + if (jj_scan_token(WITH)) return true; + if (jj_scan_token(TYPE)) return true; + return false; + } + + final private boolean jj_3_138() { + if (jj_3R_87()) return true; + return false; + } + + final private boolean jj_3_137() { + if (jj_3R_86()) return true; + return false; + } + + final private boolean jj_3_136() { + if (jj_3R_85()) return true; + return false; + } + + final private boolean jj_3_135() { + if (jj_3R_84()) return true; + return false; + } + + final private boolean jj_3_134() { + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_462() { + if (jj_scan_token(BIG_QUERY_QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3R_117() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_134()) { + jj_scanpos = xsp; + if (jj_3_135()) { + jj_scanpos = xsp; + if (jj_3_136()) { + jj_scanpos = xsp; + if (jj_3_137()) { + jj_scanpos = xsp; + if (jj_3_138()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_461() { + if (jj_scan_token(BIG_QUERY_DOUBLE_QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_133() { + if (jj_scan_token(AS)) return true; + if (jj_scan_token(DOT_FORMAT)) return true; + return false; + } + + final private boolean jj_3_132() { + if (jj_scan_token(AS)) return true; + if (jj_scan_token(JSON)) return true; + return false; + } + + final private boolean jj_3_131() { + if (jj_scan_token(AS)) return true; + if (jj_scan_token(XML)) return true; + return false; + } + + final private boolean jj_3_130() { + if (jj_3R_115()) return true; + return false; + } + + final private boolean jj_3R_82() { + if (jj_scan_token(EXPLAIN)) return true; + if (jj_scan_token(PLAN)) return true; + return false; + } + + final private boolean jj_3_458() { + if (jj_scan_token(UESCAPE)) return true; + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3R_200() { + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_129() { + if (jj_scan_token(FROM)) return true; + if (jj_3R_114()) return true; + return false; + } + + final private boolean jj_3_457() { + if (jj_scan_token(UNICODE_STRING_LITERAL)) return true; + return false; + } + + final private boolean jj_3_456() { + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3_455() { + if (jj_scan_token(PREFIXED_STRING_LITERAL)) return true; + return false; + } + + final private boolean jj_3_128() { + if (jj_3R_64()) return true; + return false; + } + + final private boolean jj_3_460() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_455()) { + jj_scanpos = xsp; + if (jj_3_456()) { + jj_scanpos = xsp; + if (jj_3_457()) return true; + } + } + while (true) { + xsp = jj_scanpos; + if (jj_3R_200()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3_458()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_127() { + if (jj_scan_token(STREAM)) return true; + return false; + } + + final private boolean jj_3_126() { + if (jj_scan_token(HINT_BEG)) return true; + if (jj_3R_113()) return true; + return false; + } + + final private boolean jj_3R_58() { + if (jj_scan_token(SELECT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_126()) jj_scanpos = xsp; + if (jj_3R_270()) return true; + return false; + } + + final private boolean jj_3R_199() { + if (jj_scan_token(QUOTED_STRING)) return true; + return false; + } + + final private boolean jj_3R_108() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_459()) { + jj_scanpos = xsp; + if (jj_3_460()) { + jj_scanpos = xsp; + if (jj_3_461()) { + jj_scanpos = xsp; + if (jj_3_462()) return true; + } + } + } + return false; + } + + final private boolean jj_3_459() { + if (jj_scan_token(BINARY_STRING_LITERAL)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_199()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_125() { + if (jj_scan_token(HINT_BEG)) return true; + if (jj_3R_113()) return true; + return false; + } + + final private boolean jj_3R_130() { + if (jj_3R_287()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_125()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_121() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_454() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_453() { + if (jj_scan_token(UNKNOWN)) return true; + return false; + } + + final private boolean jj_3_124() { + if (jj_3R_112()) return true; + return false; + } + + final private boolean jj_3_452() { + if (jj_scan_token(FALSE)) return true; + return false; + } + + final private boolean jj_3R_196() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_451()) { + jj_scanpos = xsp; + if (jj_3_452()) { + jj_scanpos = xsp; + if (jj_3_453()) { + jj_scanpos = xsp; + if (jj_3_454()) return true; + } + } + } + return false; + } + + final private boolean jj_3_451() { + if (jj_scan_token(TRUE)) return true; + return false; + } + + final private boolean jj_3_123() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_122() { + if (jj_3R_111()) return true; + return false; + } + + final private boolean jj_3_450() { + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_449() { + if (jj_scan_token(MINUS)) return true; + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_120() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_109() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_448()) { + jj_scanpos = xsp; + if (jj_3_449()) { + jj_scanpos = xsp; + if (jj_3_450()) return true; + } + } + return false; + } + + final private boolean jj_3_448() { + if (jj_scan_token(PLUS)) return true; + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_116() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_447() { + if (jj_scan_token(APPROX_NUMERIC_LITERAL)) return true; + return false; + } + + final private boolean jj_3_119() { + if (jj_3R_112()) return true; + return false; + } + + final private boolean jj_3_446() { + if (jj_scan_token(DECIMAL_NUMERIC_LITERAL)) return true; + return false; + } + + final private boolean jj_3_118() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3R_154() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_445()) { + jj_scanpos = xsp; + if (jj_3_446()) { + jj_scanpos = xsp; + if (jj_3_447()) return true; + } + } + return false; + } + + final private boolean jj_3_445() { + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_117() { + if (jj_3R_111()) return true; + return false; + } + + final private boolean jj_3_444() { + if (jj_3R_195()) return true; + return false; + } + + final private boolean jj_3R_113() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_443() { + if (jj_3R_198()) return true; + return false; + } + + final private boolean jj_3R_176() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_443()) { + jj_scanpos = xsp; + if (jj_3_444()) return true; + } + return false; + } + + final private boolean jj_3_115() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_110()) return true; + return false; + } + + final private boolean jj_3_442() { + if (jj_3R_197()) return true; + return false; + } + + final private boolean jj_3_441() { + if (jj_3R_196()) return true; + return false; + } + + final private boolean jj_3_440() { + if (jj_3R_108()) return true; + return false; + } + + final private boolean jj_3_439() { + if (jj_3R_109()) return true; + return false; + } + + final private boolean jj_3R_112() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_110()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_115()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3R_195() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_439()) { + jj_scanpos = xsp; + if (jj_3_440()) { + jj_scanpos = xsp; + if (jj_3_441()) { + jj_scanpos = xsp; + if (jj_3_442()) return true; + } + } + } + return false; + } + + final private boolean jj_3_438() { + if (jj_3R_149()) return true; + return false; + } + + final private boolean jj_3_114() { + if (jj_3R_108()) return true; + return false; + } + + final private boolean jj_3_437() { + if (jj_3R_195()) return true; + return false; + } + + final private boolean jj_3_113() { + if (jj_3R_109()) return true; + return false; + } + + final private boolean jj_3R_90() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_437()) { + jj_scanpos = xsp; + if (jj_3_438()) return true; + } + return false; + } + + final private boolean jj_3R_110() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_113()) { + jj_scanpos = xsp; + if (jj_3_114()) return true; + } + return false; + } + + final private boolean jj_3_112() { + if (jj_3R_108()) return true; + return false; + } + + final private boolean jj_3_111() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_436() { + if (jj_3R_194()) return true; + return false; + } + + final private boolean jj_3_435() { + if (jj_3R_193()) return true; + return false; + } + + final private boolean jj_3R_107() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_111()) { + jj_scanpos = xsp; + if (jj_3_112()) return true; + } + if (jj_scan_token(EQ)) return true; + if (jj_3R_108()) return true; + return false; + } + + final private boolean jj_3_434() { + if (jj_3R_192()) return true; + return false; + } + + final private boolean jj_3_109() { + if (jj_scan_token(TRANSACTION)) return true; + return false; + } + + final private boolean jj_3R_81() { + if (jj_scan_token(DROP)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_434()) { + jj_scanpos = xsp; + if (jj_3_435()) { + jj_scanpos = xsp; + if (jj_3_436()) return true; + } + } + return false; + } + + final private boolean jj_3_110() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_107()) return true; + return false; + } + + final private boolean jj_3_108() { + if (jj_scan_token(TRANSACTION)) return true; + return false; + } + + final private boolean jj_3_433() { + if (jj_3R_191()) return true; + return false; + } + + final private boolean jj_3R_111() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_107()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_110()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_432() { + if (jj_3R_190()) return true; + return false; + } + + final private boolean jj_3_431() { + if (jj_3R_189()) return true; + return false; + } + + final private boolean jj_3_430() { + if (jj_scan_token(OR)) return true; + if (jj_scan_token(REPLACE)) return true; + return false; + } + + final private boolean jj_3R_77() { + if (jj_scan_token(ROLLBACK)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_109()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3R_80() { + if (jj_scan_token(CREATE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_430()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_431()) { + jj_scanpos = xsp; + if (jj_3_432()) { + jj_scanpos = xsp; + if (jj_3_433()) return true; + } + } + return false; + } + + final private boolean jj_3_429() { + if (jj_scan_token(SESSION)) return true; + return false; + } + + final private boolean jj_3R_76() { + if (jj_scan_token(COMMIT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_108()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_1000() { + if (jj_scan_token(JSON)) return true; + return false; + } + + final private boolean jj_3_999() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(SCALAR)) return true; + return false; + } + + final private boolean jj_3_428() { + if (jj_scan_token(SYSTEM)) return true; + return false; + } + + final private boolean jj_3_998() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_997() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(OBJECT)) return true; + return false; + } + + final private boolean jj_3R_273() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_428()) { + jj_scanpos = xsp; + if (jj_3_429()) return true; + } + return false; + } + + final private boolean jj_3_996() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(VALUE)) return true; + return false; + } + + final private boolean jj_3_1005() { + if (jj_scan_token(FORMAT)) return true; + if (jj_3R_241()) return true; + return false; + } + + final private boolean jj_3_995() { + if (jj_scan_token(EMPTY)) return true; + return false; + } + + final private boolean jj_3_994() { + if (jj_scan_token(UNKNOWN)) return true; + return false; + } + + final private boolean jj_3_993() { + if (jj_scan_token(FALSE)) return true; + return false; + } + + final private boolean jj_3_992() { + if (jj_scan_token(TRUE)) return true; + return false; + } + + final private boolean jj_3_991() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_990() { + if (jj_scan_token(JSON)) return true; + return false; + } + + final private boolean jj_3_989() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(SCALAR)) return true; + return false; + } + + final private boolean jj_3_1003() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_991()) { + jj_scanpos = xsp; + if (jj_3_992()) { + jj_scanpos = xsp; + if (jj_3_993()) { + jj_scanpos = xsp; + if (jj_3_994()) { + jj_scanpos = xsp; + if (jj_3_995()) { + jj_scanpos = xsp; + if (jj_3_996()) { + jj_scanpos = xsp; + if (jj_3_997()) { + jj_scanpos = xsp; + if (jj_3_998()) { + jj_scanpos = xsp; + if (jj_3_999()) { + jj_scanpos = xsp; + if (jj_3_1000()) return true; + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_988() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3R_75() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(QUERY)) return true; + return false; + } + + final private boolean jj_3_987() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(OBJECT)) return true; + return false; + } + + final private boolean jj_3_986() { + if (jj_scan_token(JSON)) return true; + if (jj_scan_token(VALUE)) return true; + return false; + } + + final private boolean jj_3_985() { + if (jj_scan_token(EMPTY)) return true; + return false; + } + + final private boolean jj_3R_79() { + if (jj_scan_token(ALTER)) return true; + if (jj_3R_273()) return true; + return false; + } + + final private boolean jj_3_984() { + if (jj_scan_token(A)) return true; + if (jj_scan_token(SET)) return true; + return false; + } + + final private boolean jj_3_983() { + if (jj_scan_token(UNKNOWN)) return true; + return false; + } + + final private boolean jj_3_982() { + if (jj_scan_token(FALSE)) return true; + return false; + } + + final private boolean jj_3_981() { + if (jj_scan_token(TRUE)) return true; + return false; + } + + final private boolean jj_3_980() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_107() { + if (jj_scan_token(ASYNC)) return true; + return false; + } + + final private boolean jj_3_1002() { + if (jj_scan_token(NOT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_980()) { + jj_scanpos = xsp; + if (jj_3_981()) { + jj_scanpos = xsp; + if (jj_3_982()) { + jj_scanpos = xsp; + if (jj_3_983()) { + jj_scanpos = xsp; + if (jj_3_984()) { + jj_scanpos = xsp; + if (jj_3_985()) { + jj_scanpos = xsp; + if (jj_3_986()) { + jj_scanpos = xsp; + if (jj_3_987()) { + jj_scanpos = xsp; + if (jj_3_988()) { + jj_scanpos = xsp; + if (jj_3_989()) { + jj_scanpos = xsp; + if (jj_3_990()) return true; + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_1001() { + if (jj_scan_token(A)) return true; + if (jj_scan_token(SET)) return true; + return false; + } + + final private boolean jj_3_425() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3R_74() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(COMPUTE)) return true; + return false; + } + + final private boolean jj_3_424() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3R_169() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_1004()) { + jj_scanpos = xsp; + if (jj_3_1005()) return true; + } + return false; + } + + final private boolean jj_3_1004() { + if (jj_scan_token(IS)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_1001()) { + jj_scanpos = xsp; + if (jj_3_1002()) { + jj_scanpos = xsp; + if (jj_3_1003()) return true; + } + } + return false; + } + + final private boolean jj_3_427() { + if (jj_scan_token(RESET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_424()) { + jj_scanpos = xsp; + if (jj_3_425()) return true; + } + return false; + } + + final private boolean jj_3_979() { + if (jj_scan_token(UNIQUE)) return true; + return false; + } + + final private boolean jj_3_978() { + if (jj_scan_token(EXISTS)) return true; + return false; + } + + final private boolean jj_3R_72() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(SERVICE)) return true; + return false; + } + + final private boolean jj_3_977() { + if (jj_scan_token(NOT)) return true; + return false; + } + + final private boolean jj_3_423() { + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_976() { + if (jj_scan_token(MINUS)) return true; + return false; + } + + final private boolean jj_3R_312() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_975()) { + jj_scanpos = xsp; + if (jj_3_976()) { + jj_scanpos = xsp; + if (jj_3_977()) { + jj_scanpos = xsp; + if (jj_3_978()) { + jj_scanpos = xsp; + if (jj_3_979()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_975() { + if (jj_scan_token(PLUS)) return true; + return false; + } + + final private boolean jj_3_422() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_421() { + if (jj_3R_90()) return true; + return false; + } + + final private boolean jj_3_974() { + if (jj_3R_266()) return true; + return false; + } + + final private boolean jj_3R_73() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(TRANSACTION)) return true; + return false; + } + + final private boolean jj_3_973() { + if (jj_scan_token(IMMEDIATELY)) return true; + if (jj_scan_token(SUCCEEDS)) return true; + return false; + } + + final private boolean jj_3_972() { + if (jj_scan_token(IMMEDIATELY)) return true; + if (jj_scan_token(PRECEDES)) return true; + return false; + } + + final private boolean jj_3_971() { + if (jj_scan_token(SUCCEEDS)) return true; + return false; + } + + final private boolean jj_3_426() { + if (jj_scan_token(SET)) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_970() { + if (jj_scan_token(PRECEDES)) return true; + return false; + } + + final private boolean jj_3_969() { + if (jj_scan_token(EQUALS)) return true; + return false; + } + + final private boolean jj_3_968() { + if (jj_scan_token(OVERLAPS)) return true; + return false; + } + + final private boolean jj_3_967() { + if (jj_scan_token(CONTAINS)) return true; + return false; + } + + final private boolean jj_3_966() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(SUBMULTISET)) return true; + if (jj_scan_token(OF)) return true; + return false; + } + + final private boolean jj_3R_78() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_426()) { + jj_scanpos = xsp; + if (jj_3_427()) return true; + } + return false; + } + + final private boolean jj_3_965() { + if (jj_scan_token(SUBMULTISET)) return true; + if (jj_scan_token(OF)) return true; + return false; + } + + final private boolean jj_3_964() { + if (jj_scan_token(MEMBER)) return true; + if (jj_scan_token(OF)) return true; + return false; + } + + final private boolean jj_3_963() { + if (jj_scan_token(IS)) return true; + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_962() { + if (jj_scan_token(IS)) return true; + if (jj_scan_token(DISTINCT)) return true; + if (jj_scan_token(FROM)) return true; + return false; + } + + final private boolean jj_3_961() { + if (jj_scan_token(OR)) return true; + return false; + } + + final private boolean jj_3R_71() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(CONTINUOUS)) return true; + return false; + } + + final private boolean jj_3_960() { + if (jj_scan_token(AND)) return true; + return false; + } + + final private boolean jj_3_959() { + if (jj_scan_token(CONCAT)) return true; + return false; + } + + final private boolean jj_3_958() { + if (jj_scan_token(PERCENT_REMAINDER)) return true; + return false; + } + + final private boolean jj_3_957() { + if (jj_scan_token(SLASH)) return true; + return false; + } + + final private boolean jj_3_420() { + if (jj_scan_token(CURRENT)) return true; + return false; + } + + final private boolean jj_3_956() { + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_955() { + if (jj_scan_token(MINUS)) return true; + return false; + } + + final private boolean jj_3_419() { + if (jj_scan_token(NEXT)) return true; + return false; + } + + final private boolean jj_3_954() { + if (jj_scan_token(PLUS)) return true; + return false; + } + + final private boolean jj_3R_187() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_419()) { + jj_scanpos = xsp; + if (jj_3_420()) return true; + } + if (jj_scan_token(VALUE)) return true; + return false; + } + + final private boolean jj_3R_70() { + if (jj_scan_token(KILL)) return true; + if (jj_scan_token(SCAN)) return true; + return false; + } + + final private boolean jj_3_953() { + if (jj_scan_token(NE2)) return true; + return false; + } + + final private boolean jj_3_952() { + if (jj_scan_token(NE)) return true; + return false; + } + + final private boolean jj_3_951() { + if (jj_scan_token(GE)) return true; + return false; + } + + final private boolean jj_3_950() { + if (jj_scan_token(LE)) return true; + return false; + } + + final private boolean jj_3_949() { + if (jj_scan_token(LT)) return true; + return false; + } + + final private boolean jj_3_948() { + if (jj_scan_token(GT)) return true; + return false; + } + + final private boolean jj_3R_168() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_947()) { + jj_scanpos = xsp; + if (jj_3_948()) { + jj_scanpos = xsp; + if (jj_3_949()) { + jj_scanpos = xsp; + if (jj_3_950()) { + jj_scanpos = xsp; + if (jj_3_951()) { + jj_scanpos = xsp; + if (jj_3_952()) { + jj_scanpos = xsp; + if (jj_3_953()) { + jj_scanpos = xsp; + if (jj_3_954()) { + jj_scanpos = xsp; + if (jj_3_955()) { + jj_scanpos = xsp; + if (jj_3_956()) { + jj_scanpos = xsp; + if (jj_3_957()) { + jj_scanpos = xsp; + if (jj_3_958()) { + jj_scanpos = xsp; + if (jj_3_959()) { + jj_scanpos = xsp; + if (jj_3_960()) { + jj_scanpos = xsp; + if (jj_3_961()) { + jj_scanpos = xsp; + if (jj_3_962()) { + jj_scanpos = xsp; + if (jj_3_963()) { + jj_scanpos = xsp; + if (jj_3_964()) { + jj_scanpos = xsp; + if (jj_3_965()) { + jj_scanpos = xsp; + if (jj_3_966()) { + jj_scanpos = xsp; + if (jj_3_967()) { + jj_scanpos = xsp; + if (jj_3_968()) { + jj_scanpos = xsp; + if (jj_3_969()) { + jj_scanpos = xsp; + if (jj_3_970()) { + jj_scanpos = xsp; + if (jj_3_971()) { + jj_scanpos = xsp; + if (jj_3_972()) { + jj_scanpos = xsp; + if (jj_3_973()) { + jj_scanpos = xsp; + if (jj_3_974()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_947() { + if (jj_scan_token(EQ)) return true; + return false; + } + + final private boolean jj_3_418() { + if (jj_scan_token(ELSE)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_942() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_941() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_943() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_941()) { + jj_scanpos = xsp; + if (jj_3_942()) return true; + } + return false; + } + + final private boolean jj_3_939() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_946() { + if (jj_scan_token(EXCEPT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_943()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_938() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_940() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_938()) { + jj_scanpos = xsp; + if (jj_3_939()) return true; + } + return false; + } + + final private boolean jj_3_417() { + if (jj_scan_token(WHEN)) return true; + if (jj_3R_188()) return true; + return false; + } + + final private boolean jj_3_936() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_945() { + if (jj_scan_token(INTERSECT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_940()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_416() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_935() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_937() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_935()) { + jj_scanpos = xsp; + if (jj_3_936()) return true; + } + return false; + } + + final private boolean jj_3R_186() { + if (jj_scan_token(CASE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_416()) jj_scanpos = xsp; + if (jj_3_417()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3_417()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_944() { + if (jj_scan_token(UNION)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_937()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3R_266() { + if (jj_scan_token(MULTISET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_944()) { + jj_scanpos = xsp; + if (jj_3_945()) { + jj_scanpos = xsp; + if (jj_3_946()) return true; + } + } + return false; + } + + final private boolean jj_3R_265() { + return false; + } + + final private boolean jj_3_931() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_415() { + if (jj_3R_187()) return true; + return false; + } + + final private boolean jj_3_410() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(521)) jj_scanpos = xsp; + if (jj_3R_183()) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_930() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_106() { + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_414() { + if (jj_3R_186()) return true; + return false; + } + + final private boolean jj_3_413() { + if (jj_3R_185()) return true; + return false; + } + + final private boolean jj_3_105() { + if (jj_scan_token(MINUS)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_412() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_929() { + if (jj_scan_token(SET_MINUS)) return true; + return false; + } + + final private boolean jj_3_411() { + if (jj_3R_184()) return true; + return false; + } + + final private boolean jj_3_928() { + if (jj_scan_token(EXCEPT)) return true; + return false; + } + + final private boolean jj_3_104() { + if (jj_scan_token(PLUS)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3R_295() { + if (jj_3R_290()) return true; + return false; + } + + final private boolean jj_3R_264() { + return false; + } + + final private boolean jj_3_927() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_934() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_928()) { + jj_scanpos = xsp; + if (jj_3_929()) return true; + } + xsp = jj_scanpos; + if (jj_3_930()) { + jj_scanpos = xsp; + if (jj_3_931()) { + jj_scanpos = xsp; + if (jj_3R_265()) return true; + } + } + return false; + } + + final private boolean jj_3_926() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_409() { + if (jj_3R_182()) return true; + return false; + } + + final private boolean jj_3_408() { + if (jj_3R_181()) return true; + return false; + } + + final private boolean jj_3R_263() { + return false; + } + + final private boolean jj_3_407() { + if (jj_3R_180()) return true; + return false; + } + + final private boolean jj_3_925() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_933() { + if (jj_scan_token(INTERSECT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_926()) { + jj_scanpos = xsp; + if (jj_3_927()) { + jj_scanpos = xsp; + if (jj_3R_264()) return true; + } + } + return false; + } + + final private boolean jj_3_924() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_406() { + if (jj_3R_179()) return true; + return false; + } + + final private boolean jj_3_405() { + if (jj_3R_178()) return true; + return false; + } + + final private boolean jj_3R_194() { + if (jj_scan_token(USER)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_404() { + if (jj_3R_177()) return true; + return false; + } + + final private boolean jj_3_932() { + if (jj_scan_token(UNION)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_924()) { + jj_scanpos = xsp; + if (jj_3_925()) { + jj_scanpos = xsp; + if (jj_3R_263()) return true; + } + } + return false; + } + + final private boolean jj_3_914() { + if (jj_scan_token(TRUNCATE)) return true; + return false; + } + + final private boolean jj_3_403() { + if (jj_3R_173()) return true; + return false; + } + + final private boolean jj_3_402() { + if (jj_3R_176()) return true; + return false; + } + + final private boolean jj_3R_159() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_932()) { + jj_scanpos = xsp; + if (jj_3_933()) { + jj_scanpos = xsp; + if (jj_3_934()) return true; + } + } + return false; + } + + final private boolean jj_3R_171() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_402()) { + jj_scanpos = xsp; + if (jj_3_403()) { + jj_scanpos = xsp; + if (jj_3_404()) { + jj_scanpos = xsp; + if (jj_3_405()) { + jj_scanpos = xsp; + if (jj_3_406()) { + jj_scanpos = xsp; + if (jj_3_407()) { + jj_scanpos = xsp; + if (jj_3_408()) { + jj_scanpos = xsp; + if (jj_3_409()) { + jj_scanpos = xsp; + if (jj_3R_295()) { + jj_scanpos = xsp; + if (jj_3_411()) { + jj_scanpos = xsp; + if (jj_3_412()) { + jj_scanpos = xsp; + if (jj_3_413()) { + jj_scanpos = xsp; + if (jj_3_414()) { + jj_scanpos = xsp; + if (jj_3_415()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3R_69() { + if (jj_scan_token(ALTER)) return true; + if (jj_scan_token(USER)) return true; + return false; + } + + final private boolean jj_3_913() { + if (jj_scan_token(RIGHT)) return true; + return false; + } + + final private boolean jj_3_920() { + if (jj_3R_133()) return true; + return false; + } + + final private boolean jj_3_919() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_912() { + if (jj_scan_token(LEFT)) return true; + return false; + } + + final private boolean jj_3R_191() { + if (jj_scan_token(USER)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_99() { + if (jj_scan_token(COLUMN)) return true; + return false; + } + + final private boolean jj_3_918() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_917() { + if (jj_3R_261()) return true; + return false; + } + + final private boolean jj_3_98() { + if (jj_scan_token(COLUMN)) return true; + return false; + } + + final private boolean jj_3_916() { + if (jj_3R_260()) return true; + return false; + } + + final private boolean jj_3_401() { + if (jj_scan_token(SEPARATOR)) return true; + if (jj_3R_108()) return true; + return false; + } + + final private boolean jj_3_103() { + if (jj_scan_token(DROP)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_99()) jj_scanpos = xsp; + if (jj_3R_105()) return true; + if (jj_3R_106()) return true; + return false; + } + + final private boolean jj_3_915() { + if (jj_3R_259()) return true; + return false; + } + + final private boolean jj_3_911() { + if (jj_scan_token(INSERT)) return true; + return false; + } + + final private boolean jj_3_400() { + if (jj_3R_56()) return true; + return false; + } + + final private boolean jj_3R_262() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_911()) { + jj_scanpos = xsp; + if (jj_3_912()) { + jj_scanpos = xsp; + if (jj_3_913()) { + jj_scanpos = xsp; + if (jj_3_914()) return true; + } + } + } + return false; + } + + final private boolean jj_3_102() { + if (jj_scan_token(ADD)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_98()) jj_scanpos = xsp; + if (jj_3R_103()) return true; + if (jj_3R_104()) return true; + return false; + } + + final private boolean jj_3_101() { + if (jj_scan_token(NOLOGGING)) return true; + return false; + } + + final private boolean jj_3_100() { + if (jj_scan_token(LOGGING)) return true; + return false; + } + + final private boolean jj_3_399() { + if (jj_3R_175()) return true; + return false; + } + + final private boolean jj_3_923() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_262()) { + jj_scanpos = xsp; + if (jj_3_915()) { + jj_scanpos = xsp; + if (jj_3_916()) { + jj_scanpos = xsp; + if (jj_3_917()) return true; + } + } + } + xsp = jj_scanpos; + if (jj_3_918()) { + jj_scanpos = xsp; + if (jj_3_919()) { + jj_scanpos = xsp; + if (jj_3_920()) return true; + } + } + return false; + } + + final private boolean jj_3R_68() { + if (jj_scan_token(ALTER)) return true; + if (jj_scan_token(TABLE)) return true; + return false; + } + + final private boolean jj_3_398() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_65()) return true; + return false; + } + + final private boolean jj_3_397() { + if (jj_3R_64()) return true; + return false; + } + + final private boolean jj_3_922() { + if (jj_scan_token(CONVERT)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_396() { + if (jj_scan_token(STRING_AGG)) return true; + return false; + } + + final private boolean jj_3_395() { + if (jj_scan_token(GROUP_CONCAT)) return true; + return false; + } + + final private boolean jj_3_394() { + if (jj_scan_token(ARRAY_CONCAT_AGG)) return true; + return false; + } + + final private boolean jj_3_921() { + if (jj_3R_231()) return true; + return false; + } + + final private boolean jj_3_97() { + if (jj_3R_102()) return true; + return false; + } + + final private boolean jj_3_393() { + if (jj_scan_token(ARRAY_AGG)) return true; + return false; + } + + final private boolean jj_3R_104() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_96()) { + jj_scanpos = xsp; + if (jj_3_97()) return true; + } + return false; + } + + final private boolean jj_3_96() { + if (jj_3R_101()) return true; + return false; + } + + final private boolean jj_3R_297() { + if (jj_3R_230()) return true; + return false; + } + + final private boolean jj_3R_254() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_393()) { + jj_scanpos = xsp; + if (jj_3_394()) { + jj_scanpos = xsp; + if (jj_3_395()) { + jj_scanpos = xsp; + if (jj_3_396()) return true; + } + } + } + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_178() { + if (jj_scan_token(LBRACE_FN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_297()) { + jj_scanpos = xsp; + if (jj_3_921()) { + jj_scanpos = xsp; + if (jj_3_922()) { + jj_scanpos = xsp; + if (jj_3_923()) return true; + } + } + } + return false; + } + + final private boolean jj_3_95() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3R_101() { + if (jj_3R_66()) return true; + if (jj_3R_94()) return true; + return false; + } + + final private boolean jj_3_391() { + if (jj_3R_174()) return true; + return false; + } + + final private boolean jj_3_910() { + if (jj_scan_token(USER)) return true; + return false; + } + + final private boolean jj_3_94() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_101()) return true; + return false; + } + + final private boolean jj_3_390() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_909() { + if (jj_scan_token(SYSTEM_USER)) return true; + return false; + } + + final private boolean jj_3_908() { + if (jj_scan_token(SESSION_USER)) return true; + return false; + } + + final private boolean jj_3_907() { + if (jj_scan_token(LOCALTIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_392() { + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_906() { + if (jj_scan_token(LOCALTIME)) return true; + return false; + } + + final private boolean jj_3_905() { + if (jj_scan_token(CURRENT_USER)) return true; + return false; + } + + final private boolean jj_3_389() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_904() { + if (jj_scan_token(CURRENT_TIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_903() { + if (jj_scan_token(CURRENT_TIME)) return true; + return false; + } + + final private boolean jj_3R_102() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_101()) return true; + return false; + } + + final private boolean jj_3_902() { + if (jj_scan_token(CURRENT_SCHEMA)) return true; + return false; + } + + final private boolean jj_3_901() { + if (jj_scan_token(CURRENT_ROLE)) return true; + return false; + } + + final private boolean jj_3_900() { + if (jj_scan_token(CURRENT_PATH)) return true; + return false; + } + + final private boolean jj_3_899() { + if (jj_scan_token(CURRENT_DEFAULT_TRANSFORM_GROUP)) return true; + return false; + } + + final private boolean jj_3_898() { + if (jj_scan_token(CURRENT_DATE)) return true; + return false; + } + + final private boolean jj_3_897() { + if (jj_scan_token(CURRENT_CATALOG)) return true; + return false; + } + + final private boolean jj_3R_184() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_897()) { + jj_scanpos = xsp; + if (jj_3_898()) { + jj_scanpos = xsp; + if (jj_3_899()) { + jj_scanpos = xsp; + if (jj_3_900()) { + jj_scanpos = xsp; + if (jj_3_901()) { + jj_scanpos = xsp; + if (jj_3_902()) { + jj_scanpos = xsp; + if (jj_3_903()) { + jj_scanpos = xsp; + if (jj_3_904()) { + jj_scanpos = xsp; + if (jj_3_905()) { + jj_scanpos = xsp; + if (jj_3_906()) { + jj_scanpos = xsp; + if (jj_3_907()) { + jj_scanpos = xsp; + if (jj_3_908()) { + jj_scanpos = xsp; + if (jj_3_909()) { + jj_scanpos = xsp; + if (jj_3_910()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3R_162() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_896() { + if (jj_scan_token(YEAR)) return true; + return false; + } + + final private boolean jj_3R_167() { + if (jj_scan_token(INFIX_CAST)) return true; + if (jj_3R_94()) return true; + return false; + } + + final private boolean jj_3_895() { + if (jj_scan_token(VAR_SAMP)) return true; + return false; + } + + final private boolean jj_3_894() { + if (jj_scan_token(VAR_POP)) return true; + return false; + } + + final private boolean jj_3_893() { + if (jj_scan_token(USER)) return true; + return false; + } + + final private boolean jj_3_892() { + if (jj_scan_token(TRUNCATE)) return true; + return false; + } + + final private boolean jj_3_891() { + if (jj_scan_token(UPPER)) return true; + return false; + } + + final private boolean jj_3_890() { + if (jj_scan_token(SUM)) return true; + return false; + } + + final private boolean jj_3_889() { + if (jj_scan_token(STDDEV_SAMP)) return true; + return false; + } + + final private boolean jj_3_888() { + if (jj_scan_token(STDDEV_POP)) return true; + return false; + } + + final private boolean jj_3_887() { + if (jj_scan_token(SQRT)) return true; + return false; + } + + final private boolean jj_3_886() { + if (jj_scan_token(SOME)) return true; + return false; + } + + final private boolean jj_3R_193() { + if (jj_scan_token(INDEX)) return true; + if (jj_3R_105()) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_885() { + if (jj_scan_token(SECOND)) return true; + return false; + } + + final private boolean jj_3_884() { + if (jj_scan_token(ROW_NUMBER)) return true; + return false; + } + + final private boolean jj_3_883() { + if (jj_scan_token(RIGHT)) return true; + return false; + } + + final private boolean jj_3_388() { + if (jj_3R_173()) return true; + return false; + } + + final private boolean jj_3_882() { + if (jj_scan_token(REGR_SYY)) return true; + return false; + } + + final private boolean jj_3_881() { + if (jj_scan_token(REGR_SXX)) return true; + return false; + } + + final private boolean jj_3_387() { + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_880() { + if (jj_scan_token(REGR_COUNT)) return true; + return false; + } + + final private boolean jj_3_879() { + if (jj_scan_token(RANK)) return true; + return false; + } + + final private boolean jj_3_878() { + if (jj_scan_token(POWER)) return true; + return false; + } + + final private boolean jj_3_877() { + if (jj_scan_token(PERCENTILE_DISC)) return true; + return false; + } + + final private boolean jj_3_876() { + if (jj_scan_token(PERCENTILE_CONT)) return true; + return false; + } + + final private boolean jj_3R_57() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_387()) { + jj_scanpos = xsp; + if (jj_3_388()) return true; + } + return false; + } + + final private boolean jj_3_875() { + if (jj_scan_token(PERCENT_RANK)) return true; + return false; + } + + final private boolean jj_3R_192() { + if (jj_scan_token(TABLE)) return true; + if (jj_3R_105()) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_874() { + if (jj_scan_token(OCTET_LENGTH)) return true; + return false; + } + + final private boolean jj_3_873() { + if (jj_scan_token(NULLIF)) return true; + return false; + } + + final private boolean jj_3_872() { + if (jj_scan_token(NTILE)) return true; + return false; + } + + final private boolean jj_3_871() { + if (jj_scan_token(NTH_VALUE)) return true; + return false; + } + + final private boolean jj_3_870() { + if (jj_scan_token(MONTH)) return true; + return false; + } + + final private boolean jj_3_869() { + if (jj_scan_token(MOD)) return true; + return false; + } + + final private boolean jj_3_868() { + if (jj_scan_token(MINUTE)) return true; + return false; + } + + final private boolean jj_3_867() { + if (jj_scan_token(MIN)) return true; + return false; + } + + final private boolean jj_3_866() { + if (jj_scan_token(MAX)) return true; + return false; + } + + final private boolean jj_3R_281() { + return false; + } + + final private boolean jj_3_865() { + if (jj_scan_token(LOWER)) return true; + return false; + } + + final private boolean jj_3_864() { + if (jj_scan_token(LOCALTIMESTAMP)) return true; + return false; + } + + final private boolean jj_3R_105() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_93()) { + jj_scanpos = xsp; + if (jj_3R_281()) return true; + } + return false; + } + + final private boolean jj_3_93() { + if (jj_scan_token(IF)) return true; + if (jj_scan_token(EXISTS)) return true; + return false; + } + + final private boolean jj_3_863() { + if (jj_scan_token(LOCALTIME)) return true; + return false; + } + + final private boolean jj_3_862() { + if (jj_scan_token(LN)) return true; + return false; + } + + final private boolean jj_3_861() { + if (jj_scan_token(LAST_VALUE)) return true; + return false; + } + + final private boolean jj_3_860() { + if (jj_scan_token(LEFT)) return true; + return false; + } + + final private boolean jj_3_859() { + if (jj_scan_token(LEAD)) return true; + return false; + } + + final private boolean jj_3_858() { + if (jj_scan_token(LAG)) return true; + return false; + } + + final private boolean jj_3_857() { + if (jj_scan_token(HOUR)) return true; + return false; + } + + final private boolean jj_3_856() { + if (jj_scan_token(GROUPING)) return true; + return false; + } + + final private boolean jj_3_855() { + if (jj_scan_token(INTERSECTION)) return true; + return false; + } + + final private boolean jj_3_854() { + if (jj_scan_token(FUSION)) return true; + return false; + } + + final private boolean jj_3_853() { + if (jj_scan_token(FLOOR)) return true; + return false; + } + + final private boolean jj_3_852() { + if (jj_scan_token(FIRST_VALUE)) return true; + return false; + } + + final private boolean jj_3_92() { + if (jj_scan_token(INLINE_SIZE)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_386() { + if (jj_scan_token(EQUALS)) return true; + return false; + } + + final private boolean jj_3_851() { + if (jj_scan_token(EXP)) return true; + return false; + } + + final private boolean jj_3_850() { + if (jj_scan_token(EVERY)) return true; + return false; + } + + final private boolean jj_3_385() { + if (jj_scan_token(SUCCEEDS)) return true; + return false; + } + + final private boolean jj_3_849() { + if (jj_scan_token(ELEMENT)) return true; + return false; + } + + final private boolean jj_3_848() { + if (jj_scan_token(DENSE_RANK)) return true; + return false; + } + + final private boolean jj_3_384() { + if (jj_scan_token(IMMEDIATELY)) return true; + if (jj_scan_token(SUCCEEDS)) return true; + return false; + } + + final private boolean jj_3_847() { + if (jj_scan_token(CURRENT_TIMESTAMP)) return true; + return false; + } + + final private boolean jj_3_846() { + if (jj_scan_token(CURRENT_TIME)) return true; + return false; + } + + final private boolean jj_3_383() { + if (jj_scan_token(PRECEDES)) return true; + return false; + } + + final private boolean jj_3_845() { + if (jj_scan_token(CURRENT_DATE)) return true; + return false; + } + + final private boolean jj_3_91() { + if (jj_scan_token(PARALLEL)) return true; + if (jj_scan_token(UNSIGNED_INTEGER_LITERAL)) return true; + return false; + } + + final private boolean jj_3_90() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_91()) { + jj_scanpos = xsp; + if (jj_3_92()) return true; + } + return false; + } + + final private boolean jj_3_844() { + if (jj_scan_token(COUNT)) return true; + return false; + } + + final private boolean jj_3_843() { + if (jj_scan_token(CUME_DIST)) return true; + return false; + } + + final private boolean jj_3_382() { + if (jj_scan_token(IMMEDIATELY)) return true; + if (jj_scan_token(PRECEDES)) return true; + return false; + } + + final private boolean jj_3_842() { + if (jj_scan_token(COVAR_SAMP)) return true; + return false; + } + + final private boolean jj_3_841() { + if (jj_scan_token(COVAR_POP)) return true; + return false; + } + + final private boolean jj_3_381() { + if (jj_scan_token(OVERLAPS)) return true; + return false; + } + + final private boolean jj_3_840() { + if (jj_scan_token(COLLECT)) return true; + return false; + } + + final private boolean jj_3_839() { + if (jj_scan_token(COALESCE)) return true; + return false; + } + + final private boolean jj_3_838() { + if (jj_scan_token(CHARACTER_LENGTH)) return true; + return false; + } + + final private boolean jj_3_837() { + if (jj_scan_token(CHAR_LENGTH)) return true; + return false; + } + + final private boolean jj_3_836() { + if (jj_scan_token(CEILING)) return true; + return false; + } + + final private boolean jj_3_835() { + if (jj_scan_token(CARDINALITY)) return true; + return false; + } + + final private boolean jj_3_834() { + if (jj_scan_token(AVG)) return true; + return false; + } + + final private boolean jj_3R_190() { + if (jj_scan_token(INDEX)) return true; + if (jj_3R_103()) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_833() { + if (jj_scan_token(ABS)) return true; + return false; + } + + final private boolean jj_3R_259() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_833()) { + jj_scanpos = xsp; + if (jj_3_834()) { + jj_scanpos = xsp; + if (jj_3_835()) { + jj_scanpos = xsp; + if (jj_3_836()) { + jj_scanpos = xsp; + if (jj_3_837()) { + jj_scanpos = xsp; + if (jj_3_838()) { + jj_scanpos = xsp; + if (jj_3_839()) { + jj_scanpos = xsp; + if (jj_3_840()) { + jj_scanpos = xsp; + if (jj_3_841()) { + jj_scanpos = xsp; + if (jj_3_842()) { + jj_scanpos = xsp; + if (jj_3_843()) { + jj_scanpos = xsp; + if (jj_3_844()) { + jj_scanpos = xsp; + if (jj_3_845()) { + jj_scanpos = xsp; + if (jj_3_846()) { + jj_scanpos = xsp; + if (jj_3_847()) { + jj_scanpos = xsp; + if (jj_3_848()) { + jj_scanpos = xsp; + if (jj_3_849()) { + jj_scanpos = xsp; + if (jj_3_850()) { + jj_scanpos = xsp; + if (jj_3_851()) { + jj_scanpos = xsp; + if (jj_3_852()) { + jj_scanpos = xsp; + if (jj_3_853()) { + jj_scanpos = xsp; + if (jj_3_854()) { + jj_scanpos = xsp; + if (jj_3_855()) { + jj_scanpos = xsp; + if (jj_3_856()) { + jj_scanpos = xsp; + if (jj_3_857()) { + jj_scanpos = xsp; + if (jj_3_858()) { + jj_scanpos = xsp; + if (jj_3_859()) { + jj_scanpos = xsp; + if (jj_3_860()) { + jj_scanpos = xsp; + if (jj_3_861()) { + jj_scanpos = xsp; + if (jj_3_862()) { + jj_scanpos = xsp; + if (jj_3_863()) { + jj_scanpos = xsp; + if (jj_3_864()) { + jj_scanpos = xsp; + if (jj_3_865()) { + jj_scanpos = xsp; + if (jj_3_866()) { + jj_scanpos = xsp; + if (jj_3_867()) { + jj_scanpos = xsp; + if (jj_3_868()) { + jj_scanpos = xsp; + if (jj_3_869()) { + jj_scanpos = xsp; + if (jj_3_870()) { + jj_scanpos = xsp; + if (jj_3_871()) { + jj_scanpos = xsp; + if (jj_3_872()) { + jj_scanpos = xsp; + if (jj_3_873()) { + jj_scanpos = xsp; + if (jj_3_874()) { + jj_scanpos = xsp; + if (jj_3_875()) { + jj_scanpos = xsp; + if (jj_3_876()) { + jj_scanpos = xsp; + if (jj_3_877()) { + jj_scanpos = xsp; + if (jj_3_878()) { + jj_scanpos = xsp; + if (jj_3_879()) { + jj_scanpos = xsp; + if (jj_3_880()) { + jj_scanpos = xsp; + if (jj_3_881()) { + jj_scanpos = xsp; + if (jj_3_882()) { + jj_scanpos = xsp; + if (jj_3_883()) { + jj_scanpos = xsp; + if (jj_3_884()) { + jj_scanpos = xsp; + if (jj_3_885()) { + jj_scanpos = xsp; + if (jj_3_886()) { + jj_scanpos = xsp; + if (jj_3_887()) { + jj_scanpos = xsp; + if (jj_3_888()) { + jj_scanpos = xsp; + if (jj_3_889()) { + jj_scanpos = xsp; + if (jj_3_890()) { + jj_scanpos = xsp; + if (jj_3_891()) { + jj_scanpos = xsp; + if (jj_3_892()) { + jj_scanpos = xsp; + if (jj_3_893()) { + jj_scanpos = xsp; + if (jj_3_894()) { + jj_scanpos = xsp; + if (jj_3_895()) { + jj_scanpos = xsp; + if (jj_3_896()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_89() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_100()) return true; + return false; + } + + final private boolean jj_3_832() { + if (jj_3R_259()) return true; + return false; + } + + final private boolean jj_3_831() { + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3R_183() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_831()) { + jj_scanpos = xsp; + if (jj_3_832()) return true; + } + return false; + } + + final private boolean jj_3_87() { + if (jj_scan_token(DESC)) return true; + return false; + } + + final private boolean jj_3_88() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_86()) { + jj_scanpos = xsp; + if (jj_3_87()) return true; + } + return false; + } + + final private boolean jj_3_86() { + if (jj_scan_token(ASC)) return true; + return false; + } + + final private boolean jj_3R_260() { + if (jj_scan_token(SUBSTRING)) return true; + return false; + } + + final private boolean jj_3R_100() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_98() { + return false; + } + + final private boolean jj_3_829() { + if (jj_3R_258()) return true; + return false; + } + + final private boolean jj_3_83() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3_376() { + if (jj_3R_170()) return true; + return false; + } + + final private boolean jj_3_828() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_85() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_83()) { + jj_scanpos = xsp; + if (jj_3R_98()) return true; + } + if (jj_3R_99()) return true; + if (jj_scan_token(AS)) return true; + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_830() { + if (jj_scan_token(OVER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_828()) { + jj_scanpos = xsp; + if (jj_3_829()) return true; + } + return false; + } + + final private boolean jj_3_84() { + if (jj_3R_97()) return true; + return false; + } + + final private boolean jj_3_375() { + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_380() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_375()) jj_scanpos = xsp; + if (jj_3R_133()) return true; + return false; + } + + final private boolean jj_3R_189() { + if (jj_scan_token(TABLE)) return true; + if (jj_3R_103()) return true; + if (jj_3R_116()) return true; + return false; + } + + final private boolean jj_3_827() { + if (jj_scan_token(TO)) return true; + if (jj_3R_228()) return true; + return false; + } + + final private boolean jj_3R_303() { + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_82() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_95()) return true; + return false; + } + + final private boolean jj_3_379() { + if (jj_scan_token(ROW)) return true; + if (jj_3R_133()) return true; + return false; + } + + final private boolean jj_3_378() { + if (jj_3R_172()) return true; + return false; + } + + final private boolean jj_3R_97() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_95()) return true; + return false; + } + + final private boolean jj_3R_164() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_377()) { + jj_scanpos = xsp; + if (jj_3_378()) { + jj_scanpos = xsp; + if (jj_3_379()) { + jj_scanpos = xsp; + if (jj_3_380()) return true; + } + } + } + return false; + } + + final private boolean jj_3_377() { + if (jj_3R_171()) return true; + return false; + } + + final private boolean jj_3_826() { + if (jj_3R_174()) return true; + return false; + } + + final private boolean jj_3_79() { + if (jj_scan_token(CONSTRAINT)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_825() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_81() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_79()) jj_scanpos = xsp; + if (jj_scan_token(PRIMARY)) return true; + if (jj_scan_token(KEY)) return true; + return false; + } + + final private boolean jj_3_824() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_78() { + if (jj_scan_token(PRIMARY)) return true; + if (jj_scan_token(KEY)) return true; + return false; + } + + final private boolean jj_3R_307() { + return false; + } + + final private boolean jj_3_374() { + if (jj_scan_token(NE2)) return true; + return false; + } + + final private boolean jj_3_373() { + if (jj_scan_token(NE)) return true; + return false; + } + + final private boolean jj_3_823() { + if (jj_scan_token(SPECIFIC)) return true; + return false; + } + + final private boolean jj_3_372() { + if (jj_scan_token(EQ)) return true; + return false; + } + + final private boolean jj_3_77() { + if (jj_scan_token(DEFAULT_)) return true; + if (jj_3R_90()) return true; + return false; + } + + final private boolean jj_3_371() { + if (jj_scan_token(GE)) return true; + return false; + } + + final private boolean jj_3R_255() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_823()) { + jj_scanpos = xsp; + if (jj_3R_307()) return true; + } + if (jj_3R_183()) return true; + return false; + } + + final private boolean jj_3_370() { + if (jj_scan_token(GT)) return true; + return false; + } + + final private boolean jj_3_369() { + if (jj_scan_token(LE)) return true; + return false; + } + + final private boolean jj_3R_163() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_368()) { + jj_scanpos = xsp; + if (jj_3_369()) { + jj_scanpos = xsp; + if (jj_3_370()) { + jj_scanpos = xsp; + if (jj_3_371()) { + jj_scanpos = xsp; + if (jj_3_372()) { + jj_scanpos = xsp; + if (jj_3_373()) { + jj_scanpos = xsp; + if (jj_3_374()) return true; + } + } + } + } + } + } + return false; + } + + final private boolean jj_3R_95() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_80()) { + jj_scanpos = xsp; + if (jj_3_81()) return true; + } + return false; + } + + final private boolean jj_3_80() { + if (jj_3R_66()) return true; + if (jj_3R_94()) return true; + return false; + } + + final private boolean jj_3_368() { + if (jj_scan_token(LT)) return true; + return false; + } + + final private boolean jj_3R_310() { + return false; + } + + final private boolean jj_3_821() { + if (jj_3R_258()) return true; + return false; + } + + final private boolean jj_3_820() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_365() { + if (jj_3R_169()) return true; + return false; + } + + final private boolean jj_3_822() { + if (jj_scan_token(OVER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_820()) { + jj_scanpos = xsp; + if (jj_3_821()) return true; + } + return false; + } + + final private boolean jj_3_358() { + if (jj_scan_token(DOT)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_93() { + if (jj_scan_token(UUID)) return true; + return false; + } + + final private boolean jj_3_819() { + if (jj_scan_token(FILTER)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_92() { + if (jj_scan_token(INTERVAL)) return true; + if (jj_3R_170()) return true; + return false; + } + + final private boolean jj_3_818() { + if (jj_3R_250()) return true; + return false; + } + + final private boolean jj_3_364() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_817() { + if (jj_3R_257()) return true; + return false; + } + + final private boolean jj_3_363() { + if (jj_3R_168()) return true; + if (jj_3R_165()) return true; + return false; + } + + final private boolean jj_3_816() { + if (jj_3R_256()) return true; + return false; + } + + final private boolean jj_3_76() { + if (jj_3R_93()) return true; + return false; + } + + final private boolean jj_3_362() { + if (jj_3R_167()) return true; + return false; + } + + final private boolean jj_3_75() { + if (jj_3R_92()) return true; + return false; + } + + final private boolean jj_3_815() { + if (jj_3R_255()) return true; + return false; + } + + final private boolean jj_3_74() { + if (jj_3R_91()) return true; + return false; + } + + final private boolean jj_3_814() { + if (jj_3R_254()) return true; + return false; + } + + final private boolean jj_3_357() { + if (jj_scan_token(ESCAPE)) return true; + if (jj_3R_164()) return true; + return false; + } + + final private boolean jj_3R_94() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_74()) { + jj_scanpos = xsp; + if (jj_3_75()) { + jj_scanpos = xsp; + if (jj_3_76()) return true; + } + } + return false; + } + + final private boolean jj_3R_290() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_814()) { + jj_scanpos = xsp; + if (jj_3_815()) return true; + } + return false; + } + + final private boolean jj_3_353() { + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_356() { + if (jj_scan_token(TILDE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_353()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_352() { + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_73() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_351() { + if (jj_scan_token(SIMILAR)) return true; + if (jj_scan_token(TO)) return true; + return false; + } + + final private boolean jj_3_72() { + if (jj_3R_90()) return true; + return false; + } + + final private boolean jj_3_355() { + if (jj_scan_token(NEGATE)) return true; + if (jj_scan_token(TILDE)) return true; + return false; + } + + final private boolean jj_3_350() { + if (jj_scan_token(RLIKE)) return true; + return false; + } + + final private boolean jj_3_349() { + if (jj_scan_token(ILIKE)) return true; + return false; + } + + final private boolean jj_3_346() { + if (jj_scan_token(SIMILAR)) return true; + if (jj_scan_token(TO)) return true; + return false; + } + + final private boolean jj_3_348() { + if (jj_scan_token(LIKE)) return true; + return false; + } + + final private boolean jj_3_345() { + if (jj_scan_token(RLIKE)) return true; + return false; + } + + final private boolean jj_3R_89() { + if (jj_3R_277()) return true; + return false; + } + + final private boolean jj_3_344() { + if (jj_scan_token(ILIKE)) return true; + return false; + } + + final private boolean jj_3_343() { + if (jj_scan_token(LIKE)) return true; + return false; + } + + final private boolean jj_3_347() { + if (jj_scan_token(NOT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_343()) { + jj_scanpos = xsp; + if (jj_3_344()) { + jj_scanpos = xsp; + if (jj_3_345()) { + jj_scanpos = xsp; + if (jj_3_346()) return true; + } + } + } + return false; + } + + final private boolean jj_3_71() { + if (jj_scan_token(ENCRYPTED)) return true; + return false; + } + + final private boolean jj_3_70() { + if (jj_scan_token(VALUE_TYPE)) return true; + return false; + } + + final private boolean jj_3R_256() { + if (jj_3R_175()) return true; + return false; + } + + final private boolean jj_3_69() { + if (jj_scan_token(KEY_TYPE)) return true; + return false; + } + + final private boolean jj_3_354() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_347()) { + jj_scanpos = xsp; + if (jj_3_348()) { + jj_scanpos = xsp; + if (jj_3_349()) { + jj_scanpos = xsp; + if (jj_3_350()) { + jj_scanpos = xsp; + if (jj_3_351()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_68() { + if (jj_scan_token(DATA_REGION)) return true; + return false; + } + + final private boolean jj_3_67() { + if (jj_scan_token(CACHE_NAME)) return true; + return false; + } + + final private boolean jj_3_66() { + if (jj_scan_token(CACHE_GROUP)) return true; + return false; + } + + final private boolean jj_3_65() { + if (jj_scan_token(WRITE_SYNCHRONIZATION_MODE)) return true; + return false; + } + + final private boolean jj_3_361() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_354()) { + jj_scanpos = xsp; + if (jj_3_355()) { + jj_scanpos = xsp; + if (jj_3_356()) return true; + } + } + if (jj_3R_166()) return true; + return false; + } + + final private boolean jj_3_813() { + if (jj_scan_token(RESPECT)) return true; + if (jj_scan_token(NULLS)) return true; + return false; + } + + final private boolean jj_3_64() { + if (jj_scan_token(ATOMICITY)) return true; + return false; + } + + final private boolean jj_3_339() { + if (jj_scan_token(ASYMMETRIC)) return true; + return false; + } + + final private boolean jj_3_63() { + if (jj_scan_token(AFFINITY_KEY)) return true; + return false; + } + + final private boolean jj_3_340() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_338()) { + jj_scanpos = xsp; + if (jj_3_339()) return true; + } + return false; + } + + final private boolean jj_3_338() { + if (jj_scan_token(SYMMETRIC)) return true; + return false; + } + + final private boolean jj_3R_175() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_812()) { + jj_scanpos = xsp; + if (jj_3_813()) return true; + } + return false; + } + + final private boolean jj_3_812() { + if (jj_scan_token(IGNORE)) return true; + if (jj_scan_token(NULLS)) return true; + return false; + } + + final private boolean jj_3_62() { + if (jj_scan_token(BACKUPS)) return true; + return false; + } + + final private boolean jj_3R_277() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_61()) { + jj_scanpos = xsp; + if (jj_3_62()) { + jj_scanpos = xsp; + if (jj_3_63()) { + jj_scanpos = xsp; + if (jj_3_64()) { + jj_scanpos = xsp; + if (jj_3_65()) { + jj_scanpos = xsp; + if (jj_3_66()) { + jj_scanpos = xsp; + if (jj_3_67()) { + jj_scanpos = xsp; + if (jj_3_68()) { + jj_scanpos = xsp; + if (jj_3_69()) { + jj_scanpos = xsp; + if (jj_3_70()) { + jj_scanpos = xsp; + if (jj_3_71()) return true; + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_61() { + if (jj_scan_token(TEMPLATE)) return true; + return false; + } + + final private boolean jj_3_59() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_89()) return true; + return false; + } + + final private boolean jj_3_336() { + if (jj_scan_token(ASYMMETRIC)) return true; + return false; + } + + final private boolean jj_3_342() { + if (jj_scan_token(BETWEEN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_340()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_337() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_335()) { + jj_scanpos = xsp; + if (jj_3_336()) return true; + } + return false; + } + + final private boolean jj_3_335() { + if (jj_scan_token(SYMMETRIC)) return true; + return false; + } + + final private boolean jj_3R_250() { + if (jj_scan_token(WITHIN)) return true; + if (jj_scan_token(GROUP)) return true; + return false; + } + + final private boolean jj_3_60() { + if (jj_scan_token(WITH)) return true; + if (jj_3R_89()) return true; + return false; + } + + final private boolean jj_3_341() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(BETWEEN)) return true; + return false; + } + + final private boolean jj_3R_99() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_60()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_360() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_341()) { + jj_scanpos = xsp; + if (jj_3_342()) return true; + } + if (jj_3R_165()) return true; + return false; + } + + final private boolean jj_3R_280() { + return false; + } + + final private boolean jj_3R_257() { + if (jj_scan_token(WITHIN)) return true; + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3R_103() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_58()) { + jj_scanpos = xsp; + if (jj_3R_280()) return true; + } + return false; + } + + final private boolean jj_3_58() { + if (jj_scan_token(IF)) return true; + if (jj_scan_token(NOT)) return true; + return false; + } + + final private boolean jj_3_331() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3_811() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_109()) return true; + return false; + } + + final private boolean jj_3_330() { + if (jj_scan_token(ANY)) return true; + return false; + } + + final private boolean jj_3_329() { + if (jj_scan_token(SOME)) return true; + return false; + } + + final private boolean jj_3_810() { + if (jj_scan_token(NEXT)) return true; + return false; + } + + final private boolean jj_3_809() { + if (jj_scan_token(PREV)) return true; + return false; + } + + final private boolean jj_3R_252() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_809()) { + jj_scanpos = xsp; + if (jj_3_810()) return true; + } + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_334() { + if (jj_3R_163()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_329()) { + jj_scanpos = xsp; + if (jj_3_330()) { + jj_scanpos = xsp; + if (jj_3_331()) return true; + } + } + return false; + } + + final private boolean jj_3_57() { + if (jj_3R_88()) return true; + return false; + } + + final private boolean jj_3_333() { + if (jj_scan_token(IN)) return true; + return false; + } + + final private boolean jj_3_56() { + if (jj_3R_87()) return true; + return false; + } + + final private boolean jj_3_332() { + if (jj_scan_token(NOT)) return true; + if (jj_scan_token(IN)) return true; + return false; + } + + final private boolean jj_3_55() { + if (jj_3R_86()) return true; + return false; + } + + final private boolean jj_3_54() { + if (jj_3R_85()) return true; + return false; + } + + final private boolean jj_3_53() { + if (jj_3R_84()) return true; + return false; + } + + final private boolean jj_3_52() { + if (jj_3R_83()) return true; + return false; + } + + final private boolean jj_3_359() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_332()) { + jj_scanpos = xsp; + if (jj_3_333()) { + jj_scanpos = xsp; + if (jj_3_334()) return true; + } + } + if (jj_3R_133()) return true; + return false; + } + + final private boolean jj_3_51() { + if (jj_3R_82()) return true; + return false; + } + + final private boolean jj_3_50() { + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_49() { + if (jj_3R_81()) return true; + return false; + } + + final private boolean jj_3_808() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_109()) return true; + return false; + } + + final private boolean jj_3_48() { + if (jj_3R_80()) return true; + return false; + } + + final private boolean jj_3_366() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_359()) { + jj_scanpos = xsp; + if (jj_3_360()) { + jj_scanpos = xsp; + if (jj_3_361()) { + jj_scanpos = xsp; + if (jj_3_362()) { + jj_scanpos = xsp; + if (jj_3_363()) { + jj_scanpos = xsp; + if (jj_3_364()) { + jj_scanpos = xsp; + if (jj_3_365()) return true; + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_807() { + if (jj_scan_token(LAST)) return true; + return false; + } + + final private boolean jj_3_47() { + if (jj_3R_79()) return true; + return false; + } + + final private boolean jj_3_806() { + if (jj_scan_token(FIRST)) return true; + return false; + } + + final private boolean jj_3_46() { + if (jj_3R_78()) return true; + return false; + } + + final private boolean jj_3R_306() { + return false; + } + + final private boolean jj_3_45() { + if (jj_3R_77()) return true; + return false; + } + + final private boolean jj_3_367() { + Token xsp; + if (jj_3_366()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3_366()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_44() { + if (jj_3R_76()) return true; + return false; + } + + final private boolean jj_3_805() { + if (jj_scan_token(FINAL)) return true; + return false; + } + + final private boolean jj_3_43() { + if (jj_3R_75()) return true; + return false; + } + + final private boolean jj_3_804() { + if (jj_scan_token(RUNNING)) return true; + return false; + } + + final private boolean jj_3R_166() { + if (jj_3R_165()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_367()) { + jj_scanpos = xsp; + if (jj_3R_310()) return true; + } + return false; + } + + final private boolean jj_3_42() { + if (jj_3R_74()) return true; + return false; + } + + final private boolean jj_3_41() { + if (jj_3R_73()) return true; + return false; + } + + final private boolean jj_3R_251() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_804()) { + jj_scanpos = xsp; + if (jj_3_805()) { + jj_scanpos = xsp; + if (jj_3R_306()) return true; + } + } + xsp = jj_scanpos; + if (jj_3_806()) { + jj_scanpos = xsp; + if (jj_3_807()) return true; + } + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_40() { + if (jj_3R_72()) return true; + return false; + } + + final private boolean jj_3_39() { + if (jj_3R_71()) return true; + return false; + } + + final private boolean jj_3_38() { + if (jj_3R_70()) return true; + return false; + } + + final private boolean jj_3_37() { + if (jj_3R_69()) return true; + return false; + } + + final private boolean jj_3_36() { + if (jj_3R_68()) return true; + return false; + } + + final private boolean jj_3R_67() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_36()) { + jj_scanpos = xsp; + if (jj_3_37()) { + jj_scanpos = xsp; + if (jj_3_38()) { + jj_scanpos = xsp; + if (jj_3_39()) { + jj_scanpos = xsp; + if (jj_3_40()) { + jj_scanpos = xsp; + if (jj_3_41()) { + jj_scanpos = xsp; + if (jj_3_42()) { + jj_scanpos = xsp; + if (jj_3_43()) { + jj_scanpos = xsp; + if (jj_3_44()) { + jj_scanpos = xsp; + if (jj_3_45()) { + jj_scanpos = xsp; + if (jj_3_46()) { + jj_scanpos = xsp; + if (jj_3_47()) { + jj_scanpos = xsp; + if (jj_3_48()) { + jj_scanpos = xsp; + if (jj_3_49()) { + jj_scanpos = xsp; + if (jj_3_50()) { + jj_scanpos = xsp; + if (jj_3_51()) { + jj_scanpos = xsp; + if (jj_3_52()) { + jj_scanpos = xsp; + if (jj_3_53()) { + jj_scanpos = xsp; + if (jj_3_54()) { + jj_scanpos = xsp; + if (jj_3_55()) { + jj_scanpos = xsp; + if (jj_3_56()) { + jj_scanpos = xsp; + if (jj_3_57()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_803() { + if (jj_scan_token(FINAL)) return true; + return false; + } + + final private boolean jj_3_802() { + if (jj_scan_token(RUNNING)) return true; + return false; + } + + final private boolean jj_3R_253() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_802()) { + jj_scanpos = xsp; + if (jj_3_803()) return true; + } + if (jj_3R_290()) return true; + return false; + } + + final private boolean jj_3_35() { + if (jj_3R_67()) return true; + return false; + } + + final private boolean jj_3_328() { + if (jj_scan_token(DOT)) return true; + if (jj_3R_162()) return true; + return false; + } + + final private boolean jj_3_801() { + if (jj_3R_253()) return true; + return false; + } + + final private boolean jj_3_34() { + if (jj_scan_token(SEMICOLON)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_35()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_800() { + if (jj_3R_252()) return true; + return false; + } + + final private boolean jj_3_799() { + if (jj_3R_251()) return true; + return false; + } + + final private boolean jj_3R_294() { + if (jj_3R_312()) return true; + return false; + } + + final private boolean jj_3_798() { + if (jj_scan_token(MATCH_NUMBER)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_797() { + if (jj_scan_token(CLASSIFIER)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_165() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_294()) { jj_scanpos = xsp; break; } + } + if (jj_3R_164()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3_328()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3R_232() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_797()) { + jj_scanpos = xsp; + if (jj_3_798()) { + jj_scanpos = xsp; + if (jj_3_799()) { + jj_scanpos = xsp; + if (jj_3_800()) { + jj_scanpos = xsp; + if (jj_3_801()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3R_61() { + if (jj_3R_166()) return true; + return false; + } + + final private boolean jj_3_796() { + if (jj_scan_token(SESSION)) return true; + return false; + } + + final private boolean jj_3_795() { + if (jj_scan_token(HOP)) return true; + return false; + } + + final private boolean jj_3R_63() { + if (jj_scan_token(DEFAULT_)) return true; + return false; + } + + final private boolean jj_3_327() { + if (jj_3R_161()) return true; + return false; + } + + final private boolean jj_3_794() { + if (jj_scan_token(TUMBLE)) return true; + return false; + } + + final private boolean jj_3R_201() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_326()) { + jj_scanpos = xsp; + if (jj_3_327()) return true; + } + return false; + } + + final private boolean jj_3_326() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_240() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_794()) { + jj_scanpos = xsp; + if (jj_3_795()) { + jj_scanpos = xsp; + if (jj_3_796()) return true; + } + } + if (jj_3R_304()) return true; + return false; + } + + final private boolean jj_3_33() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_32() { + if (jj_3R_63()) return true; + return false; + } + + final private boolean jj_3_31() { + if (jj_3R_66()) return true; + if (jj_scan_token(NAMED_ARGUMENT_ASSIGNMENT)) return true; + return false; + } + + final private boolean jj_3R_65() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_31()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_32()) { + jj_scanpos = xsp; + if (jj_3_33()) return true; + } + return false; + } + + final private boolean jj_3_325() { + if (jj_3R_96()) return true; + return false; + } + + final private boolean jj_3R_160() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_231() { + if (jj_scan_token(TIMESTAMPDIFF)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_309()) return true; + return false; + } + + final private boolean jj_3_324() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_160()) return true; + return false; + } + + final private boolean jj_3_30() { + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_29() { + if (jj_3R_63()) return true; + return false; + } + + final private boolean jj_3_28() { + if (jj_3R_66()) return true; + if (jj_scan_token(NAMED_ARGUMENT_ASSIGNMENT)) return true; + return false; + } + + final private boolean jj_3R_158() { + if (jj_scan_token(WITH)) return true; + if (jj_3R_160()) return true; + return false; + } + + final private boolean jj_3R_118() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_28()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_29()) { + jj_scanpos = xsp; + if (jj_3_30()) return true; + } + return false; + } + + final private boolean jj_3R_230() { + if (jj_scan_token(TIMESTAMPADD)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_27() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3R_64() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_26()) { + jj_scanpos = xsp; + if (jj_3_27()) return true; + } + return false; + } + + final private boolean jj_3_26() { + if (jj_scan_token(DISTINCT)) return true; + return false; + } + + final private boolean jj_3_323() { + if (jj_3R_159()) return true; + return false; + } + + final private boolean jj_3_322() { + if (jj_3R_158()) return true; + return false; + } + + final private boolean jj_3R_272() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_322()) jj_scanpos = xsp; + if (jj_3R_201()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3_323()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3_25() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_65()) return true; + return false; + } + + final private boolean jj_3_793() { + if (jj_3R_250()) return true; + return false; + } + + final private boolean jj_3R_296() { + return false; + } + + final private boolean jj_3_24() { + if (jj_3R_64()) return true; + return false; + } + + final private boolean jj_3R_174() { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_24()) { + jj_scanpos = xsp; + if (jj_3R_296()) return true; + } + return false; + } + + final private boolean jj_3_792() { + if (jj_3R_249()) return true; + return false; + } + + final private boolean jj_3R_239() { + if (jj_scan_token(JSON_ARRAYAGG)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_304() { + if (jj_3R_174()) return true; + return false; + } + + final private boolean jj_3R_157() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_791() { + if (jj_3R_56()) return true; + return false; + } + + final private boolean jj_3_23() { + if (jj_3R_63()) return true; + return false; + } + + final private boolean jj_3_22() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_321() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_157()) return true; + return false; + } + + final private boolean jj_3_21() { + if (jj_scan_token(COMMA)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_22()) { + jj_scanpos = xsp; + if (jj_3_23()) return true; + } + return false; + } + + final private boolean jj_3_790() { + if (jj_3R_249()) return true; + return false; + } + + final private boolean jj_3_788() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_20() { + if (jj_3R_63()) return true; + return false; + } + + final private boolean jj_3_19() { + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_789() { + if (jj_3R_61()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_788()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3R_156() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_238() { + if (jj_scan_token(JSON_ARRAY)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_139() { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_19()) { + jj_scanpos = xsp; + if (jj_3_20()) return true; + } + return false; + } + + final private boolean jj_3_320() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_156()) return true; + return false; + } + + final private boolean jj_3_787() { + if (jj_3R_249()) return true; + return false; + } + + final private boolean jj_3R_150() { + if (jj_3R_156()) return true; + return false; + } + + final private boolean jj_3R_237() { + if (jj_scan_token(JSON_OBJECTAGG)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_315() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_155()) return true; + return false; + } + + final private boolean jj_3_18() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_786() { + if (jj_3R_249()) return true; + return false; + } + + final private boolean jj_3_319() { + if (jj_scan_token(PERMUTE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_784() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_248()) return true; + return false; + } + + final private boolean jj_3_318() { + if (jj_scan_token(LBRACE)) return true; + if (jj_scan_token(MINUS)) return true; + return false; + } + + final private boolean jj_3_317() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_155()) return true; + return false; + } + + final private boolean jj_3R_133() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_316() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_785() { + if (jj_3R_248()) return true; + return false; + } + + final private boolean jj_3R_292() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_316()) { + jj_scanpos = xsp; + if (jj_3_317()) { + jj_scanpos = xsp; + if (jj_3_318()) { + jj_scanpos = xsp; + if (jj_3_319()) return true; + } + } + } + return false; + } + + final private boolean jj_3R_236() { + if (jj_scan_token(JSON_OBJECT)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_783() { + if (jj_scan_token(ABSENT)) return true; + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_314() { + if (jj_scan_token(HOOK)) return true; + return false; + } + + final private boolean jj_3R_249() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_782()) { + jj_scanpos = xsp; + if (jj_3_783()) return true; + } + return false; + } + + final private boolean jj_3_782() { + if (jj_scan_token(NULL)) return true; + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_309() { + if (jj_scan_token(MINUS)) return true; + if (jj_3R_155()) return true; + return false; + } + + final private boolean jj_3_305() { + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_779() { + if (jj_scan_token(KEY)) return true; + if (jj_3R_247()) return true; + return false; + } + + final private boolean jj_3_308() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_154()) return true; + return false; + } + + final private boolean jj_3_7() { + if (jj_scan_token(ROWS)) return true; + return false; + } + + final private boolean jj_3_781() { + if (jj_scan_token(COLON)) return true; + return false; + } + + final private boolean jj_3_306() { + if (jj_scan_token(COMMA)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_305()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_780() { + if (jj_scan_token(VALUE)) return true; + return false; + } + + final private boolean jj_3_8() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_6()) { + jj_scanpos = xsp; + if (jj_3_7()) return true; + } + return false; + } + + final private boolean jj_3_6() { + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_307() { + if (jj_3R_154()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_306()) jj_scanpos = xsp; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + final private boolean jj_3R_305() { + if (jj_scan_token(KEY)) return true; + return false; + } + + final private boolean jj_3R_248() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_305()) jj_scanpos = xsp; + if (jj_3R_247()) return true; + xsp = jj_scanpos; + if (jj_3_780()) { + jj_scanpos = xsp; + if (jj_3_781()) return true; + } + return false; + } + + final private boolean jj_3_313() { + if (jj_scan_token(LBRACE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_307()) { + jj_scanpos = xsp; + if (jj_3_308()) { + jj_scanpos = xsp; + if (jj_3_309()) return true; + } + } + return false; + } + + final private boolean jj_3R_132() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_62()) return true; + return false; + } + + final private boolean jj_3_312() { + if (jj_scan_token(HOOK)) return true; + return false; + } + + final private boolean jj_3_311() { + if (jj_scan_token(PLUS)) return true; + return false; + } + + final private boolean jj_3R_247() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_17() { + if (jj_3R_60()) return true; + return false; + } + + final private boolean jj_3_16() { + if (jj_3R_59()) return true; + return false; + } + + final private boolean jj_3_310() { + if (jj_scan_token(STAR)) return true; + return false; + } + + final private boolean jj_3_11() { + if (jj_scan_token(NEXT)) return true; + return false; + } + + final private boolean jj_3R_161() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_15()) { + jj_scanpos = xsp; + if (jj_3_16()) { + jj_scanpos = xsp; + if (jj_3_17()) return true; + } + } + return false; + } + + final private boolean jj_3_15() { + if (jj_3R_58()) return true; + return false; + } + + final private boolean jj_3R_293() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_310()) { + jj_scanpos = xsp; + if (jj_3_311()) { + jj_scanpos = xsp; + if (jj_3_312()) { + jj_scanpos = xsp; + if (jj_3_313()) return true; + } + } + } + return false; + } + + final private boolean jj_3R_153() { + if (jj_3R_292()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_293()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_13() { + if (jj_scan_token(ROWS)) return true; + return false; + } + + final private boolean jj_3_10() { + if (jj_scan_token(FIRST)) return true; + return false; + } + + final private boolean jj_3_778() { + if (jj_3R_246()) return true; + return false; + } + + final private boolean jj_3_773() { + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_12() { + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_777() { + if (jj_3R_245()) return true; + if (jj_scan_token(WRAPPER)) return true; + return false; + } + + final private boolean jj_3_14() { + if (jj_scan_token(FETCH)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_10()) { + jj_scanpos = xsp; + if (jj_3_11()) return true; + } + return false; + } + + final private boolean jj_3_304() { + if (jj_3R_153()) return true; + return false; + } + + final private boolean jj_3_771() { + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_9() { + if (jj_scan_token(OFFSET)) return true; + if (jj_3R_57()) return true; + return false; + } + + final private boolean jj_3R_235() { + if (jj_scan_token(JSON_QUERY)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_4() { + if (jj_scan_token(ALL)) return true; + return false; + } + + final private boolean jj_3R_152() { + if (jj_3R_153()) return true; + return false; + } + + final private boolean jj_3_3() { + if (jj_3R_57()) return true; + return false; + } + + final private boolean jj_3_772() { + if (jj_scan_token(UNCONDITIONAL)) return true; + return false; + } + + final private boolean jj_3_2() { + if (jj_3R_57()) return true; + if (jj_scan_token(COMMA)) return true; + return false; + } + + final private boolean jj_3_770() { + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_776() { + if (jj_scan_token(WITH)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_772()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_773()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_303() { + if (jj_scan_token(VERTICAL_BAR)) return true; + if (jj_3R_152()) return true; + return false; + } + + final private boolean jj_3_5() { + if (jj_scan_token(LIMIT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_2()) { + jj_scanpos = xsp; + if (jj_3_3()) { + jj_scanpos = xsp; + if (jj_3_4()) return true; + } + } + return false; + } + + final private boolean jj_3_775() { + if (jj_scan_token(WITH)) return true; + if (jj_scan_token(CONDITIONAL)) return true; + return false; + } + + final private boolean jj_3R_155() { + if (jj_3R_152()) return true; + return false; + } + + final private boolean jj_3_1() { + if (jj_3R_56()) return true; + return false; + } + + final private boolean jj_3R_245() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_774()) { + jj_scanpos = xsp; + if (jj_3_775()) { + jj_scanpos = xsp; + if (jj_3_776()) return true; + } + } + return false; + } + + final private boolean jj_3_774() { + if (jj_scan_token(WITHOUT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_770()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_769() { + if (jj_scan_token(ERROR)) return true; + return false; + } + + final private boolean jj_3R_62() { + if (jj_3R_272()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_1()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_5()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_9()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_14()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3R_151() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_768() { + if (jj_scan_token(EMPTY)) return true; + return false; + } + + final private boolean jj_3_767() { + if (jj_scan_token(EMPTY)) return true; + if (jj_scan_token(OBJECT)) return true; + return false; + } + + final private boolean jj_3_302() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_151()) return true; + return false; + } + + final private boolean jj_3_766() { + if (jj_scan_token(EMPTY)) return true; + if (jj_scan_token(ARRAY)) return true; + return false; + } + + final private boolean jj_3_765() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3R_147() { + if (jj_3R_151()) return true; + return false; + } + + final private boolean jj_3_764() { + if (jj_scan_token(ERROR)) return true; + return false; + } + + final private boolean jj_3R_246() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_764()) { + jj_scanpos = xsp; + if (jj_3_765()) { + jj_scanpos = xsp; + if (jj_3_766()) { + jj_scanpos = xsp; + if (jj_3_767()) return true; + } + } + } + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_301() { + if (jj_scan_token(SUBSET)) return true; + if (jj_3R_150()) return true; + return false; + } + + final private boolean jj_3_763() { + if (jj_3R_244()) return true; + return false; + } + + final private boolean jj_3_300() { + if (jj_scan_token(WITHIN)) return true; + if (jj_3R_149()) return true; + return false; + } + + final private boolean jj_3_762() { + if (jj_3R_243()) return true; + return false; + } + + final private boolean jj_3_299() { + if (jj_scan_token(DOLLAR)) return true; + return false; + } + + final private boolean jj_3_292() { + if (jj_scan_token(LAST)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_234() { + if (jj_scan_token(JSON_VALUE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_298() { + if (jj_scan_token(CARET)) return true; + return false; + } + + final private boolean jj_3_296() { + if (jj_scan_token(PAST)) return true; + if (jj_scan_token(LAST)) return true; + return false; + } + + final private boolean jj_3R_148() { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(293)) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_761() { + if (jj_scan_token(ERROR)) return true; + return false; + } + + final private boolean jj_3_760() { + if (jj_scan_token(EMPTY)) return true; + return false; + } + + final private boolean jj_3_759() { + if (jj_scan_token(DEFAULT_)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_294() { + if (jj_scan_token(FIRST)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_758() { + if (jj_scan_token(NULL)) return true; + return false; + } + + final private boolean jj_3_293() { + if (jj_scan_token(NEXT)) return true; + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_757() { + if (jj_scan_token(ERROR)) return true; + return false; + } + + final private boolean jj_3R_244() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_757()) { + jj_scanpos = xsp; + if (jj_3_758()) { + jj_scanpos = xsp; + if (jj_3_759()) return true; + } + } + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_295() { + if (jj_scan_token(TO)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_293()) { + jj_scanpos = xsp; + if (jj_3_294()) { + jj_scanpos = xsp; + lookingAhead = true; + jj_semLA = true; + lookingAhead = false; + if (!jj_semLA || jj_3R_148()) return true; + } + } + return false; + } + + final private boolean jj_3_297() { + if (jj_scan_token(AFTER)) return true; + if (jj_scan_token(MATCH)) return true; + return false; + } + + final private boolean jj_3_756() { + if (jj_3R_242()) return true; + if (jj_scan_token(ON)) return true; + return false; + } + + final private boolean jj_3_291() { + if (jj_scan_token(ALL)) return true; + if (jj_scan_token(ROWS)) return true; + return false; + } + + final private boolean jj_3R_233() { + if (jj_scan_token(JSON_EXISTS)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_290() { + if (jj_scan_token(ONE)) return true; + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_289() { + if (jj_scan_token(MEASURES)) return true; + if (jj_3R_147()) return true; + return false; + } + + final private boolean jj_3_288() { + if (jj_3R_56()) return true; + return false; + } + + final private boolean jj_3_755() { + if (jj_scan_token(ERROR)) return true; + return false; + } + + final private boolean jj_3_287() { + if (jj_scan_token(PARTITION)) return true; + if (jj_scan_token(BY)) return true; + return false; + } + + final private boolean jj_3_754() { + if (jj_scan_token(UNKNOWN)) return true; + return false; + } + + final private boolean jj_3_753() { + if (jj_scan_token(FALSE)) return true; + return false; + } + + final private boolean jj_3R_242() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_752()) { + jj_scanpos = xsp; + if (jj_3_753()) { + jj_scanpos = xsp; + if (jj_3_754()) { + jj_scanpos = xsp; + if (jj_3_755()) return true; + } + } + } + return false; + } + + final private boolean jj_3_752() { + if (jj_scan_token(TRUE)) return true; + return false; + } + + final private boolean jj_3R_129() { + if (jj_scan_token(MATCH_RECOGNIZE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_750() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_751() { + if (jj_scan_token(PASSING)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_285() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_146()) return true; + return false; + } + + final private boolean jj_3_286() { + if (jj_scan_token(AS)) return true; + if (jj_3R_138()) return true; + return false; + } + + final private boolean jj_3R_146() { + if (jj_3R_106()) return true; + return false; + } + + final private boolean jj_3R_289() { + return false; + } + + final private boolean jj_3_284() { + if (jj_scan_token(EXCLUDE)) return true; + if (jj_scan_token(NULLS)) return true; + return false; + } + + final private boolean jj_3_283() { + if (jj_scan_token(INCLUDE)) return true; + if (jj_scan_token(NULLS)) return true; + return false; + } + + final private boolean jj_3_749() { + if (jj_scan_token(FORMAT)) return true; + if (jj_3R_241()) return true; + return false; + } + + final private boolean jj_3R_136() { + if (jj_scan_token(UNPIVOT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_283()) { + jj_scanpos = xsp; + if (jj_3_284()) { + jj_scanpos = xsp; + if (jj_3R_289()) return true; + } + } + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_243() { + if (jj_scan_token(RETURNING)) return true; + if (jj_3R_91()) return true; + return false; + } + + final private boolean jj_3R_291() { + return false; + } + + final private boolean jj_3_281() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_282() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_281()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_747() { + if (jj_scan_token(UTF32)) return true; + return false; + } + + final private boolean jj_3R_145() { + if (jj_3R_138()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_282()) { + jj_scanpos = xsp; + if (jj_3R_291()) return true; + } + return false; + } + + final private boolean jj_3_746() { + if (jj_scan_token(UTF16)) return true; + return false; + } + + final private boolean jj_3_745() { + if (jj_scan_token(UTF8)) return true; + return false; + } + + final private boolean jj_3_748() { + if (jj_scan_token(ENCODING)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_745()) { + jj_scanpos = xsp; + if (jj_3_746()) { + jj_scanpos = xsp; + if (jj_3_747()) return true; + } + } + return false; + } + + final private boolean jj_3_277() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_145()) return true; + return false; + } + + final private boolean jj_3_279() { + if (jj_scan_token(AS)) return true; + return false; + } + + final private boolean jj_3_280() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_279()) jj_scanpos = xsp; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_241() { + if (jj_scan_token(JSON)) return true; + return false; + } + + final private boolean jj_3R_144() { + if (jj_3R_290()) return true; + return false; + } + + final private boolean jj_3_276() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_144()) return true; + return false; + } + + final private boolean jj_3_744() { + if (jj_3R_240()) return true; + return false; + } + + final private boolean jj_3_743() { + if (jj_3R_239()) return true; + return false; + } + + final private boolean jj_3_742() { + if (jj_3R_238()) return true; + return false; + } + + final private boolean jj_3_741() { + if (jj_3R_237()) return true; + return false; + } + + final private boolean jj_3_740() { + if (jj_3R_236()) return true; + return false; + } + + final private boolean jj_3_739() { + if (jj_3R_235()) return true; + return false; + } + + final private boolean jj_3_738() { + if (jj_3R_234()) return true; + return false; + } + + final private boolean jj_3_737() { + if (jj_3R_233()) return true; + return false; + } + + final private boolean jj_3_278() { + if (jj_3R_145()) return true; + return false; + } + + final private boolean jj_3_736() { + if (jj_3R_232()) return true; + return false; + } + + final private boolean jj_3_735() { + if (jj_3R_231()) return true; + return false; + } + + final private boolean jj_3_734() { + if (jj_3R_230()) return true; + return false; + } + + final private boolean jj_3R_135() { + if (jj_scan_token(PIVOT)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_722() { + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_721() { + if (jj_scan_token(FROM)) return true; + return false; + } + + final private boolean jj_3R_128() { + if (jj_scan_token(FOR)) return true; + if (jj_scan_token(SYSTEM_TIME)) return true; + return false; + } + + final private boolean jj_3_720() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_718() { + if (jj_scan_token(LEADING)) return true; + return false; + } + + final private boolean jj_3_717() { + if (jj_scan_token(TRAILING)) return true; + return false; + } + + final private boolean jj_3_274() { + if (jj_scan_token(NULLS)) return true; + if (jj_scan_token(LAST)) return true; + return false; + } + + final private boolean jj_3_716() { + if (jj_scan_token(BOTH)) return true; + return false; + } + + final private boolean jj_3_719() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_716()) { + jj_scanpos = xsp; + if (jj_3_717()) { + jj_scanpos = xsp; + if (jj_3_718()) return true; + } + } + return false; + } + + final private boolean jj_3_273() { + if (jj_scan_token(NULLS)) return true; + if (jj_scan_token(FIRST)) return true; + return false; + } + + final private boolean jj_3_275() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_273()) { + jj_scanpos = xsp; + if (jj_3_274()) return true; + } + return false; + } + + final private boolean jj_3_723() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_719()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_720()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3_721()) { + jj_scanpos = xsp; + if (jj_3_722()) return true; + } + return false; + } + + final private boolean jj_3R_229() { + if (jj_3R_303()) return true; + return false; + } + + final private boolean jj_3_271() { + if (jj_scan_token(DESC)) return true; + return false; + } + + final private boolean jj_3_270() { + if (jj_scan_token(ASC)) return true; + return false; + } + + final private boolean jj_3_272() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_270()) { + jj_scanpos = xsp; + if (jj_3_271()) return true; + } + return false; + } + + final private boolean jj_3_714() { + if (jj_scan_token(COMMA)) return true; + return false; + } + + final private boolean jj_3R_143() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_733() { + if (jj_scan_token(TRIM)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_275() { + if (true) { jj_la = 0; jj_scanpos = jj_lastpos; return false;} + return false; + } + + final private boolean jj_3_712() { + if (jj_scan_token(COMMA)) return true; + return false; + } + + final private boolean jj_3_713() { + if (jj_scan_token(FOR)) return true; + return false; + } + + final private boolean jj_3_715() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_713()) { + jj_scanpos = xsp; + if (jj_3_714()) return true; + } + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_270() { + if (true) { jj_la = 0; jj_scanpos = jj_lastpos; return false;} + return false; + } + + final private boolean jj_3_269() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_143()) return true; + return false; + } + + final private boolean jj_3_710() { + if (jj_scan_token(CEILING)) return true; + return false; + } + + final private boolean jj_3_711() { + if (jj_scan_token(FROM)) return true; + return false; + } + + final private boolean jj_3_732() { + if (jj_scan_token(SUBSTRING)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_709() { + if (jj_scan_token(CEIL)) return true; + return false; + } + + final private boolean jj_3R_131() { + return false; + } + + final private boolean jj_3_731() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_709()) { + jj_scanpos = xsp; + if (jj_3_710()) return true; + } + if (jj_3R_229()) return true; + return false; + } + + final private boolean jj_3_730() { + if (jj_scan_token(FLOOR)) return true; + if (jj_3R_229()) return true; + return false; + } + + final private boolean jj_3R_56() { + if (jj_scan_token(ORDER)) return true; + if (jj_scan_token(BY)) return true; + return false; + } + + final private boolean jj_3_708() { + if (jj_scan_token(FOR)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_134() { + if (jj_3R_288()) return true; + return false; + } + + final private boolean jj_3_265() { + if (jj_scan_token(FOLLOWING)) return true; + return false; + } + + final private boolean jj_3_264() { + if (jj_scan_token(PRECEDING)) return true; + return false; + } + + final private boolean jj_3_729() { + if (jj_scan_token(OVERLAY)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_705() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_268() { + if (jj_3R_61()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_264()) { + jj_scanpos = xsp; + if (jj_3_265()) return true; + } + return false; + } + + final private boolean jj_3_263() { + if (jj_scan_token(FOLLOWING)) return true; + return false; + } + + final private boolean jj_3_707() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_705()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_262() { + if (jj_scan_token(PRECEDING)) return true; + return false; + } + + final private boolean jj_3_706() { + if (jj_scan_token(USING)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_267() { + if (jj_scan_token(UNBOUNDED)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_262()) { + jj_scanpos = xsp; + if (jj_3_263()) return true; + } + return false; + } + + final private boolean jj_3R_142() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_266()) { + jj_scanpos = xsp; + if (jj_3_267()) { + jj_scanpos = xsp; + if (jj_3_268()) return true; + } + } + return false; + } + + final private boolean jj_3_266() { + if (jj_scan_token(CURRENT)) return true; + if (jj_scan_token(ROW)) return true; + return false; + } + + final private boolean jj_3_728() { + if (jj_scan_token(TRANSLATE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_260() { + if (jj_scan_token(DISALLOW)) return true; + if (jj_scan_token(PARTIAL)) return true; + return false; + } + + final private boolean jj_3_727() { + if (jj_scan_token(CONVERT)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_704() { + if (jj_scan_token(FROM)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_257() { + if (jj_3R_142()) return true; + return false; + } + + final private boolean jj_3_259() { + if (jj_scan_token(ALLOW)) return true; + if (jj_scan_token(PARTIAL)) return true; + return false; + } + + final private boolean jj_3_261() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_259()) { + jj_scanpos = xsp; + if (jj_3_260()) return true; + } + return false; + } + + final private boolean jj_3_256() { + if (jj_scan_token(BETWEEN)) return true; + if (jj_3R_142()) return true; + return false; + } + + final private boolean jj_3_255() { + if (jj_scan_token(RANGE)) return true; + return false; + } + + final private boolean jj_3_254() { + if (jj_scan_token(ROWS)) return true; + return false; + } + + final private boolean jj_3_726() { + if (jj_scan_token(POSITION)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_258() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_254()) { + jj_scanpos = xsp; + if (jj_3_255()) return true; + } + xsp = jj_scanpos; + if (jj_3_256()) { + jj_scanpos = xsp; + if (jj_3_257()) return true; + } + return false; + } + + final private boolean jj_3_703() { + if (jj_3R_228()) return true; + return false; + } + + final private boolean jj_3_253() { + if (jj_3R_56()) return true; + return false; + } + + final private boolean jj_3_702() { + if (jj_scan_token(MICROSECOND)) return true; + return false; + } + + final private boolean jj_3_701() { + if (jj_scan_token(NANOSECOND)) return true; + return false; + } + + final private boolean jj_3_252() { + if (jj_scan_token(PARTITION)) return true; + if (jj_scan_token(BY)) return true; + return false; + } + + final private boolean jj_3R_308() { + return false; + } + + final private boolean jj_3_725() { + if (jj_scan_token(EXTRACT)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3_251() { + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3_700() { + if (jj_scan_token(INTERVAL)) return true; + if (jj_3R_170()) return true; + return false; + } + + final private boolean jj_3_699() { + if (jj_3R_91()) return true; + return false; + } + + final private boolean jj_3R_258() { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_251()) { + jj_scanpos = xsp; + if (jj_3R_308()) return true; + } + return false; + } + + final private boolean jj_3_724() { + if (jj_scan_token(CAST)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_177() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_724()) { + jj_scanpos = xsp; + if (jj_3_725()) { + jj_scanpos = xsp; + if (jj_3_726()) { + jj_scanpos = xsp; + if (jj_3_727()) { + jj_scanpos = xsp; + if (jj_3_728()) { + jj_scanpos = xsp; + if (jj_3_729()) { + jj_scanpos = xsp; + if (jj_3_730()) { + jj_scanpos = xsp; + if (jj_3_731()) { + jj_scanpos = xsp; + if (jj_3_732()) { + jj_scanpos = xsp; + if (jj_3_733()) { + jj_scanpos = xsp; + if (jj_3_734()) { + jj_scanpos = xsp; + if (jj_3_735()) { + jj_scanpos = xsp; + if (jj_3_736()) { + jj_scanpos = xsp; + if (jj_3_737()) { + jj_scanpos = xsp; + if (jj_3_738()) { + jj_scanpos = xsp; + if (jj_3_739()) { + jj_scanpos = xsp; + if (jj_3_740()) { + jj_scanpos = xsp; + if (jj_3_741()) { + jj_scanpos = xsp; + if (jj_3_742()) { + jj_scanpos = xsp; + if (jj_3_743()) { + jj_scanpos = xsp; + if (jj_3_744()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + final private boolean jj_3_249() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_311() { + return false; + } + + final private boolean jj_3R_172() { + if (jj_scan_token(CURSOR)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_250() { + if (jj_scan_token(WINDOW)) return true; + if (jj_3R_66()) return true; + return false; + } + + final private boolean jj_3R_288() { + Token xsp; + xsp = jj_scanpos; + lookingAhead = true; + jj_semLA = false; + lookingAhead = false; + if (!jj_semLA || jj_3R_311()) return true; + if (jj_scan_token(ZONE)) return true; + return false; + } + + final private boolean jj_3R_302() { + return false; + } + + final private boolean jj_3_698() { + if (jj_scan_token(WITH)) return true; + if (jj_scan_token(LOCAL)) return true; + return false; + } + + final private boolean jj_3_248() { + if (jj_scan_token(HAVING)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_227() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_697()) { + jj_scanpos = xsp; + if (jj_3_698()) { + jj_scanpos = xsp; + if (jj_3R_302()) return true; + } + } + return false; + } + + final private boolean jj_3_697() { + if (jj_scan_token(WITHOUT)) return true; + if (jj_scan_token(TIME)) return true; + if (jj_scan_token(ZONE)) return true; + return false; + } + + final private boolean jj_3_247() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3R_301() { + return false; + } + + final private boolean jj_3R_300() { + if (jj_3R_61()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_247()) { jj_scanpos = xsp; break; } + } + return false; + } + + final private boolean jj_3R_209() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_696()) { + jj_scanpos = xsp; + if (jj_3R_301()) return true; + } + return false; + } + + final private boolean jj_3_696() { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_210()) return true; + return false; + } + + final private boolean jj_3R_188() { + if (jj_3R_300()) return true; + return false; + } + + final private boolean jj_3_695() { + if (jj_scan_token(TIMESTAMP)) return true; + if (jj_3R_209()) return true; + if (jj_3R_227()) return true; + return false; + } + + final private boolean jj_3_246() { + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_245() { + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + final private boolean jj_3_694() { + if (jj_scan_token(TIME)) return true; + if (jj_3R_209()) return true; + if (jj_3R_227()) return true; + return false; + } + + final private boolean jj_3_244() { + if (jj_scan_token(CUBE)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_224() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_693()) { + jj_scanpos = xsp; + if (jj_3_694()) { + jj_scanpos = xsp; + if (jj_3_695()) return true; + } + } + return false; + } + + final private boolean jj_3_693() { + if (jj_scan_token(DATE)) return true; + return false; + } + + final private boolean jj_3_243() { + if (jj_scan_token(ROLLUP)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + final private boolean jj_3R_141() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_242()) { + jj_scanpos = xsp; + if (jj_3_243()) { + jj_scanpos = xsp; + if (jj_3_244()) { + jj_scanpos = xsp; + if (jj_3_245()) { + jj_scanpos = xsp; + if (jj_3_246()) return true; + } + } + } + } + return false; + } + + final private boolean jj_3_242() { + if (jj_scan_token(GROUPING)) return true; + if (jj_scan_token(SETS)) return true; + return false; + } + + final private boolean jj_3_688() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + final private boolean jj_3_692() { + if (jj_scan_token(CHARACTER)) return true; + if (jj_scan_token(SET)) return true; + return false; + } + + final private boolean jj_3R_226() { + return false; + } + + final private boolean jj_3_691() { + if (jj_scan_token(VARCHAR)) return true; + return false; + } + + final private boolean jj_3_241() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_141()) return true; + return false; + } + + final private boolean jj_3_689() { + if (jj_scan_token(VARYING)) return true; + return false; + } + + final private boolean jj_3_687() { + if (jj_scan_token(CHARACTER)) return true; + return false; + } + + final private boolean jj_3_690() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_687()) { + jj_scanpos = xsp; + if (jj_3_688()) return true; + } + xsp = jj_scanpos; + if (jj_3_689()) { + jj_scanpos = xsp; + if (jj_3R_226()) return true; + } + return false; + } + + final private boolean jj_3R_223() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_690()) { + jj_scanpos = xsp; + if (jj_3_691()) return true; + } + if (jj_3R_209()) return true; + xsp = jj_scanpos; + if (jj_3_692()) jj_scanpos = xsp; + return false; + } + + final private boolean jj_3_240() { + if (jj_scan_token(GROUP)) return true; + if (jj_scan_token(BY)) return true; + return false; + } + + final private boolean jj_3R_219() { + if (jj_scan_token(ROW)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_313()) return true; + return false; + } + + final private boolean jj_3_239() { + if (jj_scan_token(WHERE)) return true; + if (jj_3R_61()) return true; + return false; + } + + final private boolean jj_3_686() { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_66()) return true; + return false; + } + + public IgniteSqlParserImplTokenManager token_source; + SimpleCharStream jj_input_stream; + public Token token, jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + public boolean lookingAhead = false; + private boolean jj_semLA; + private int jj_gen; + final private int[] jj_la1 = new int[10]; + static private int[] jj_la1_0; + static private int[] jj_la1_1; + static private int[] jj_la1_2; + static private int[] jj_la1_3; + static private int[] jj_la1_4; + static private int[] jj_la1_5; + static private int[] jj_la1_6; + static private int[] jj_la1_7; + static private int[] jj_la1_8; + static private int[] jj_la1_9; + static private int[] jj_la1_10; + static private int[] jj_la1_11; + static private int[] jj_la1_12; + static private int[] jj_la1_13; + static private int[] jj_la1_14; + static private int[] jj_la1_15; + static private int[] jj_la1_16; + static private int[] jj_la1_17; + static private int[] jj_la1_18; + static private int[] jj_la1_19; + static private int[] jj_la1_20; + static private int[] jj_la1_21; + static private int[] jj_la1_22; + static private int[] jj_la1_23; + static private int[] jj_la1_24; + static { + jj_la1_0(); + jj_la1_1(); + jj_la1_2(); + jj_la1_3(); + jj_la1_4(); + jj_la1_5(); + jj_la1_6(); + jj_la1_7(); + jj_la1_8(); + jj_la1_9(); + jj_la1_10(); + jj_la1_11(); + jj_la1_12(); + jj_la1_13(); + jj_la1_14(); + jj_la1_15(); + jj_la1_16(); + jj_la1_17(); + jj_la1_18(); + jj_la1_19(); + jj_la1_20(); + jj_la1_21(); + jj_la1_22(); + jj_la1_23(); + jj_la1_24(); + } + private static void jj_la1_0() { + jj_la1_0 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_1() { + jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_2() { + jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_3() { + jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_4() { + jj_la1_4 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_5() { + jj_la1_5 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_6() { + jj_la1_6 = new int[] {0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_7() { + jj_la1_7 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_8() { + jj_la1_8 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,}; + } + private static void jj_la1_9() { + jj_la1_9 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,}; + } + private static void jj_la1_10() { + jj_la1_10 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_11() { + jj_la1_11 = new int[] {0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_12() { + jj_la1_12 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_13() { + jj_la1_13 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_14() { + jj_la1_14 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,}; + } + private static void jj_la1_15() { + jj_la1_15 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_16() { + jj_la1_16 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_17() { + jj_la1_17 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_18() { + jj_la1_18 = new int[] {0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_19() { + jj_la1_19 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x1,}; + } + private static void jj_la1_20() { + jj_la1_20 = new int[] {0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_21() { + jj_la1_21 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_22() { + jj_la1_22 = new int[] {0x0,0x10000,0x20000000,0x0,0x10000,0x10000,0x800000,0x800000,0x0,0x0,}; + } + private static void jj_la1_23() { + jj_la1_23 = new int[] {0x0,0x0,0xa080,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + private static void jj_la1_24() { + jj_la1_24 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + final private JJCalls[] jj_2_rtns = new JJCalls[1401]; + private boolean jj_rescan = false; + private int jj_gc = 0; + + public IgniteSqlParserImpl(java.io.InputStream stream) { + this(stream, null); + } + public IgniteSqlParserImpl(java.io.InputStream stream, String encoding) { + try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source = new IgniteSqlParserImplTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.InputStream stream) { + ReInit(stream, null); + } + public void ReInit(java.io.InputStream stream, String encoding) { + try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public IgniteSqlParserImpl(java.io.Reader stream) { + jj_input_stream = new SimpleCharStream(stream, 1, 1); + token_source = new IgniteSqlParserImplTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public IgniteSqlParserImpl(IgniteSqlParserImplTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(IgniteSqlParserImplTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 10; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + final private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + if (++jj_gc > 100) { + jj_gc = 0; + for (int i = 0; i < jj_2_rtns.length; i++) { + JJCalls c = jj_2_rtns[i]; + while (c != null) { + if (c.gen < jj_gen) c.first = null; + c = c.next; + } + } + } + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + static private final class LookaheadSuccess extends java.lang.Error { } + final private LookaheadSuccess jj_ls = new LookaheadSuccess(); + final private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_rescan) { + int i = 0; Token tok = token; + while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } + if (tok != null) jj_add_error_token(kind, i); + } + if (jj_scanpos.kind != kind) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; + return false; + } + + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + + final public Token getToken(int index) { + Token t = lookingAhead ? jj_scanpos : token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + final private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.Vector jj_expentries = new java.util.Vector(); + private int[] jj_expentry; + private int jj_kind = -1; + private int[] jj_lasttokens = new int[100]; + private int jj_endpos; + + private void jj_add_error_token(int kind, int pos) { + if (pos >= 100) return; + if (pos == jj_endpos + 1) { + jj_lasttokens[jj_endpos++] = kind; + } else if (jj_endpos != 0) { + jj_expentry = new int[jj_endpos]; + for (int i = 0; i < jj_endpos; i++) { + jj_expentry[i] = jj_lasttokens[i]; + } + boolean exists = false; + for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) { + int[] oldentry = (int[])(e.nextElement()); + if (oldentry.length == jj_expentry.length) { + exists = true; + for (int i = 0; i < jj_expentry.length; i++) { + if (oldentry[i] != jj_expentry[i]) { + exists = false; + break; + } + } + if (exists) break; + } + } + if (!exists) jj_expentries.addElement(jj_expentry); + if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; + } + } + + public ParseException generateParseException() { + jj_expentries.removeAllElements(); + boolean[] la1tokens = new boolean[787]; + for (int i = 0; i < 787; i++) { + la1tokens[i] = false; + } + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 10; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1< jj_gen) { + jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; + switch (i) { + case 0: jj_3_1(); break; + case 1: jj_3_2(); break; + case 2: jj_3_3(); break; + case 3: jj_3_4(); break; + case 4: jj_3_5(); break; + case 5: jj_3_6(); break; + case 6: jj_3_7(); break; + case 7: jj_3_8(); break; + case 8: jj_3_9(); break; + case 9: jj_3_10(); break; + case 10: jj_3_11(); break; + case 11: jj_3_12(); break; + case 12: jj_3_13(); break; + case 13: jj_3_14(); break; + case 14: jj_3_15(); break; + case 15: jj_3_16(); break; + case 16: jj_3_17(); break; + case 17: jj_3_18(); break; + case 18: jj_3_19(); break; + case 19: jj_3_20(); break; + case 20: jj_3_21(); break; + case 21: jj_3_22(); break; + case 22: jj_3_23(); break; + case 23: jj_3_24(); break; + case 24: jj_3_25(); break; + case 25: jj_3_26(); break; + case 26: jj_3_27(); break; + case 27: jj_3_28(); break; + case 28: jj_3_29(); break; + case 29: jj_3_30(); break; + case 30: jj_3_31(); break; + case 31: jj_3_32(); break; + case 32: jj_3_33(); break; + case 33: jj_3_34(); break; + case 34: jj_3_35(); break; + case 35: jj_3_36(); break; + case 36: jj_3_37(); break; + case 37: jj_3_38(); break; + case 38: jj_3_39(); break; + case 39: jj_3_40(); break; + case 40: jj_3_41(); break; + case 41: jj_3_42(); break; + case 42: jj_3_43(); break; + case 43: jj_3_44(); break; + case 44: jj_3_45(); break; + case 45: jj_3_46(); break; + case 46: jj_3_47(); break; + case 47: jj_3_48(); break; + case 48: jj_3_49(); break; + case 49: jj_3_50(); break; + case 50: jj_3_51(); break; + case 51: jj_3_52(); break; + case 52: jj_3_53(); break; + case 53: jj_3_54(); break; + case 54: jj_3_55(); break; + case 55: jj_3_56(); break; + case 56: jj_3_57(); break; + case 57: jj_3_58(); break; + case 58: jj_3_59(); break; + case 59: jj_3_60(); break; + case 60: jj_3_61(); break; + case 61: jj_3_62(); break; + case 62: jj_3_63(); break; + case 63: jj_3_64(); break; + case 64: jj_3_65(); break; + case 65: jj_3_66(); break; + case 66: jj_3_67(); break; + case 67: jj_3_68(); break; + case 68: jj_3_69(); break; + case 69: jj_3_70(); break; + case 70: jj_3_71(); break; + case 71: jj_3_72(); break; + case 72: jj_3_73(); break; + case 73: jj_3_74(); break; + case 74: jj_3_75(); break; + case 75: jj_3_76(); break; + case 76: jj_3_77(); break; + case 77: jj_3_78(); break; + case 78: jj_3_79(); break; + case 79: jj_3_80(); break; + case 80: jj_3_81(); break; + case 81: jj_3_82(); break; + case 82: jj_3_83(); break; + case 83: jj_3_84(); break; + case 84: jj_3_85(); break; + case 85: jj_3_86(); break; + case 86: jj_3_87(); break; + case 87: jj_3_88(); break; + case 88: jj_3_89(); break; + case 89: jj_3_90(); break; + case 90: jj_3_91(); break; + case 91: jj_3_92(); break; + case 92: jj_3_93(); break; + case 93: jj_3_94(); break; + case 94: jj_3_95(); break; + case 95: jj_3_96(); break; + case 96: jj_3_97(); break; + case 97: jj_3_98(); break; + case 98: jj_3_99(); break; + case 99: jj_3_100(); break; + case 100: jj_3_101(); break; + case 101: jj_3_102(); break; + case 102: jj_3_103(); break; + case 103: jj_3_104(); break; + case 104: jj_3_105(); break; + case 105: jj_3_106(); break; + case 106: jj_3_107(); break; + case 107: jj_3_108(); break; + case 108: jj_3_109(); break; + case 109: jj_3_110(); break; + case 110: jj_3_111(); break; + case 111: jj_3_112(); break; + case 112: jj_3_113(); break; + case 113: jj_3_114(); break; + case 114: jj_3_115(); break; + case 115: jj_3_116(); break; + case 116: jj_3_117(); break; + case 117: jj_3_118(); break; + case 118: jj_3_119(); break; + case 119: jj_3_120(); break; + case 120: jj_3_121(); break; + case 121: jj_3_122(); break; + case 122: jj_3_123(); break; + case 123: jj_3_124(); break; + case 124: jj_3_125(); break; + case 125: jj_3_126(); break; + case 126: jj_3_127(); break; + case 127: jj_3_128(); break; + case 128: jj_3_129(); break; + case 129: jj_3_130(); break; + case 130: jj_3_131(); break; + case 131: jj_3_132(); break; + case 132: jj_3_133(); break; + case 133: jj_3_134(); break; + case 134: jj_3_135(); break; + case 135: jj_3_136(); break; + case 136: jj_3_137(); break; + case 137: jj_3_138(); break; + case 138: jj_3_139(); break; + case 139: jj_3_140(); break; + case 140: jj_3_141(); break; + case 141: jj_3_142(); break; + case 142: jj_3_143(); break; + case 143: jj_3_144(); break; + case 144: jj_3_145(); break; + case 145: jj_3_146(); break; + case 146: jj_3_147(); break; + case 147: jj_3_148(); break; + case 148: jj_3_149(); break; + case 149: jj_3_150(); break; + case 150: jj_3_151(); break; + case 151: jj_3_152(); break; + case 152: jj_3_153(); break; + case 153: jj_3_154(); break; + case 154: jj_3_155(); break; + case 155: jj_3_156(); break; + case 156: jj_3_157(); break; + case 157: jj_3_158(); break; + case 158: jj_3_159(); break; + case 159: jj_3_160(); break; + case 160: jj_3_161(); break; + case 161: jj_3_162(); break; + case 162: jj_3_163(); break; + case 163: jj_3_164(); break; + case 164: jj_3_165(); break; + case 165: jj_3_166(); break; + case 166: jj_3_167(); break; + case 167: jj_3_168(); break; + case 168: jj_3_169(); break; + case 169: jj_3_170(); break; + case 170: jj_3_171(); break; + case 171: jj_3_172(); break; + case 172: jj_3_173(); break; + case 173: jj_3_174(); break; + case 174: jj_3_175(); break; + case 175: jj_3_176(); break; + case 176: jj_3_177(); break; + case 177: jj_3_178(); break; + case 178: jj_3_179(); break; + case 179: jj_3_180(); break; + case 180: jj_3_181(); break; + case 181: jj_3_182(); break; + case 182: jj_3_183(); break; + case 183: jj_3_184(); break; + case 184: jj_3_185(); break; + case 185: jj_3_186(); break; + case 186: jj_3_187(); break; + case 187: jj_3_188(); break; + case 188: jj_3_189(); break; + case 189: jj_3_190(); break; + case 190: jj_3_191(); break; + case 191: jj_3_192(); break; + case 192: jj_3_193(); break; + case 193: jj_3_194(); break; + case 194: jj_3_195(); break; + case 195: jj_3_196(); break; + case 196: jj_3_197(); break; + case 197: jj_3_198(); break; + case 198: jj_3_199(); break; + case 199: jj_3_200(); break; + case 200: jj_3_201(); break; + case 201: jj_3_202(); break; + case 202: jj_3_203(); break; + case 203: jj_3_204(); break; + case 204: jj_3_205(); break; + case 205: jj_3_206(); break; + case 206: jj_3_207(); break; + case 207: jj_3_208(); break; + case 208: jj_3_209(); break; + case 209: jj_3_210(); break; + case 210: jj_3_211(); break; + case 211: jj_3_212(); break; + case 212: jj_3_213(); break; + case 213: jj_3_214(); break; + case 214: jj_3_215(); break; + case 215: jj_3_216(); break; + case 216: jj_3_217(); break; + case 217: jj_3_218(); break; + case 218: jj_3_219(); break; + case 219: jj_3_220(); break; + case 220: jj_3_221(); break; + case 221: jj_3_222(); break; + case 222: jj_3_223(); break; + case 223: jj_3_224(); break; + case 224: jj_3_225(); break; + case 225: jj_3_226(); break; + case 226: jj_3_227(); break; + case 227: jj_3_228(); break; + case 228: jj_3_229(); break; + case 229: jj_3_230(); break; + case 230: jj_3_231(); break; + case 231: jj_3_232(); break; + case 232: jj_3_233(); break; + case 233: jj_3_234(); break; + case 234: jj_3_235(); break; + case 235: jj_3_236(); break; + case 236: jj_3_237(); break; + case 237: jj_3_238(); break; + case 238: jj_3_239(); break; + case 239: jj_3_240(); break; + case 240: jj_3_241(); break; + case 241: jj_3_242(); break; + case 242: jj_3_243(); break; + case 243: jj_3_244(); break; + case 244: jj_3_245(); break; + case 245: jj_3_246(); break; + case 246: jj_3_247(); break; + case 247: jj_3_248(); break; + case 248: jj_3_249(); break; + case 249: jj_3_250(); break; + case 250: jj_3_251(); break; + case 251: jj_3_252(); break; + case 252: jj_3_253(); break; + case 253: jj_3_254(); break; + case 254: jj_3_255(); break; + case 255: jj_3_256(); break; + case 256: jj_3_257(); break; + case 257: jj_3_258(); break; + case 258: jj_3_259(); break; + case 259: jj_3_260(); break; + case 260: jj_3_261(); break; + case 261: jj_3_262(); break; + case 262: jj_3_263(); break; + case 263: jj_3_264(); break; + case 264: jj_3_265(); break; + case 265: jj_3_266(); break; + case 266: jj_3_267(); break; + case 267: jj_3_268(); break; + case 268: jj_3_269(); break; + case 269: jj_3_270(); break; + case 270: jj_3_271(); break; + case 271: jj_3_272(); break; + case 272: jj_3_273(); break; + case 273: jj_3_274(); break; + case 274: jj_3_275(); break; + case 275: jj_3_276(); break; + case 276: jj_3_277(); break; + case 277: jj_3_278(); break; + case 278: jj_3_279(); break; + case 279: jj_3_280(); break; + case 280: jj_3_281(); break; + case 281: jj_3_282(); break; + case 282: jj_3_283(); break; + case 283: jj_3_284(); break; + case 284: jj_3_285(); break; + case 285: jj_3_286(); break; + case 286: jj_3_287(); break; + case 287: jj_3_288(); break; + case 288: jj_3_289(); break; + case 289: jj_3_290(); break; + case 290: jj_3_291(); break; + case 291: jj_3_292(); break; + case 292: jj_3_293(); break; + case 293: jj_3_294(); break; + case 294: jj_3_295(); break; + case 295: jj_3_296(); break; + case 296: jj_3_297(); break; + case 297: jj_3_298(); break; + case 298: jj_3_299(); break; + case 299: jj_3_300(); break; + case 300: jj_3_301(); break; + case 301: jj_3_302(); break; + case 302: jj_3_303(); break; + case 303: jj_3_304(); break; + case 304: jj_3_305(); break; + case 305: jj_3_306(); break; + case 306: jj_3_307(); break; + case 307: jj_3_308(); break; + case 308: jj_3_309(); break; + case 309: jj_3_310(); break; + case 310: jj_3_311(); break; + case 311: jj_3_312(); break; + case 312: jj_3_313(); break; + case 313: jj_3_314(); break; + case 314: jj_3_315(); break; + case 315: jj_3_316(); break; + case 316: jj_3_317(); break; + case 317: jj_3_318(); break; + case 318: jj_3_319(); break; + case 319: jj_3_320(); break; + case 320: jj_3_321(); break; + case 321: jj_3_322(); break; + case 322: jj_3_323(); break; + case 323: jj_3_324(); break; + case 324: jj_3_325(); break; + case 325: jj_3_326(); break; + case 326: jj_3_327(); break; + case 327: jj_3_328(); break; + case 328: jj_3_329(); break; + case 329: jj_3_330(); break; + case 330: jj_3_331(); break; + case 331: jj_3_332(); break; + case 332: jj_3_333(); break; + case 333: jj_3_334(); break; + case 334: jj_3_335(); break; + case 335: jj_3_336(); break; + case 336: jj_3_337(); break; + case 337: jj_3_338(); break; + case 338: jj_3_339(); break; + case 339: jj_3_340(); break; + case 340: jj_3_341(); break; + case 341: jj_3_342(); break; + case 342: jj_3_343(); break; + case 343: jj_3_344(); break; + case 344: jj_3_345(); break; + case 345: jj_3_346(); break; + case 346: jj_3_347(); break; + case 347: jj_3_348(); break; + case 348: jj_3_349(); break; + case 349: jj_3_350(); break; + case 350: jj_3_351(); break; + case 351: jj_3_352(); break; + case 352: jj_3_353(); break; + case 353: jj_3_354(); break; + case 354: jj_3_355(); break; + case 355: jj_3_356(); break; + case 356: jj_3_357(); break; + case 357: jj_3_358(); break; + case 358: jj_3_359(); break; + case 359: jj_3_360(); break; + case 360: jj_3_361(); break; + case 361: jj_3_362(); break; + case 362: jj_3_363(); break; + case 363: jj_3_364(); break; + case 364: jj_3_365(); break; + case 365: jj_3_366(); break; + case 366: jj_3_367(); break; + case 367: jj_3_368(); break; + case 368: jj_3_369(); break; + case 369: jj_3_370(); break; + case 370: jj_3_371(); break; + case 371: jj_3_372(); break; + case 372: jj_3_373(); break; + case 373: jj_3_374(); break; + case 374: jj_3_375(); break; + case 375: jj_3_376(); break; + case 376: jj_3_377(); break; + case 377: jj_3_378(); break; + case 378: jj_3_379(); break; + case 379: jj_3_380(); break; + case 380: jj_3_381(); break; + case 381: jj_3_382(); break; + case 382: jj_3_383(); break; + case 383: jj_3_384(); break; + case 384: jj_3_385(); break; + case 385: jj_3_386(); break; + case 386: jj_3_387(); break; + case 387: jj_3_388(); break; + case 388: jj_3_389(); break; + case 389: jj_3_390(); break; + case 390: jj_3_391(); break; + case 391: jj_3_392(); break; + case 392: jj_3_393(); break; + case 393: jj_3_394(); break; + case 394: jj_3_395(); break; + case 395: jj_3_396(); break; + case 396: jj_3_397(); break; + case 397: jj_3_398(); break; + case 398: jj_3_399(); break; + case 399: jj_3_400(); break; + case 400: jj_3_401(); break; + case 401: jj_3_402(); break; + case 402: jj_3_403(); break; + case 403: jj_3_404(); break; + case 404: jj_3_405(); break; + case 405: jj_3_406(); break; + case 406: jj_3_407(); break; + case 407: jj_3_408(); break; + case 408: jj_3_409(); break; + case 409: jj_3_410(); break; + case 410: jj_3_411(); break; + case 411: jj_3_412(); break; + case 412: jj_3_413(); break; + case 413: jj_3_414(); break; + case 414: jj_3_415(); break; + case 415: jj_3_416(); break; + case 416: jj_3_417(); break; + case 417: jj_3_418(); break; + case 418: jj_3_419(); break; + case 419: jj_3_420(); break; + case 420: jj_3_421(); break; + case 421: jj_3_422(); break; + case 422: jj_3_423(); break; + case 423: jj_3_424(); break; + case 424: jj_3_425(); break; + case 425: jj_3_426(); break; + case 426: jj_3_427(); break; + case 427: jj_3_428(); break; + case 428: jj_3_429(); break; + case 429: jj_3_430(); break; + case 430: jj_3_431(); break; + case 431: jj_3_432(); break; + case 432: jj_3_433(); break; + case 433: jj_3_434(); break; + case 434: jj_3_435(); break; + case 435: jj_3_436(); break; + case 436: jj_3_437(); break; + case 437: jj_3_438(); break; + case 438: jj_3_439(); break; + case 439: jj_3_440(); break; + case 440: jj_3_441(); break; + case 441: jj_3_442(); break; + case 442: jj_3_443(); break; + case 443: jj_3_444(); break; + case 444: jj_3_445(); break; + case 445: jj_3_446(); break; + case 446: jj_3_447(); break; + case 447: jj_3_448(); break; + case 448: jj_3_449(); break; + case 449: jj_3_450(); break; + case 450: jj_3_451(); break; + case 451: jj_3_452(); break; + case 452: jj_3_453(); break; + case 453: jj_3_454(); break; + case 454: jj_3_455(); break; + case 455: jj_3_456(); break; + case 456: jj_3_457(); break; + case 457: jj_3_458(); break; + case 458: jj_3_459(); break; + case 459: jj_3_460(); break; + case 460: jj_3_461(); break; + case 461: jj_3_462(); break; + case 462: jj_3_463(); break; + case 463: jj_3_464(); break; + case 464: jj_3_465(); break; + case 465: jj_3_466(); break; + case 466: jj_3_467(); break; + case 467: jj_3_468(); break; + case 468: jj_3_469(); break; + case 469: jj_3_470(); break; + case 470: jj_3_471(); break; + case 471: jj_3_472(); break; + case 472: jj_3_473(); break; + case 473: jj_3_474(); break; + case 474: jj_3_475(); break; + case 475: jj_3_476(); break; + case 476: jj_3_477(); break; + case 477: jj_3_478(); break; + case 478: jj_3_479(); break; + case 479: jj_3_480(); break; + case 480: jj_3_481(); break; + case 481: jj_3_482(); break; + case 482: jj_3_483(); break; + case 483: jj_3_484(); break; + case 484: jj_3_485(); break; + case 485: jj_3_486(); break; + case 486: jj_3_487(); break; + case 487: jj_3_488(); break; + case 488: jj_3_489(); break; + case 489: jj_3_490(); break; + case 490: jj_3_491(); break; + case 491: jj_3_492(); break; + case 492: jj_3_493(); break; + case 493: jj_3_494(); break; + case 494: jj_3_495(); break; + case 495: jj_3_496(); break; + case 496: jj_3_497(); break; + case 497: jj_3_498(); break; + case 498: jj_3_499(); break; + case 499: jj_3_500(); break; + case 500: jj_3_501(); break; + case 501: jj_3_502(); break; + case 502: jj_3_503(); break; + case 503: jj_3_504(); break; + case 504: jj_3_505(); break; + case 505: jj_3_506(); break; + case 506: jj_3_507(); break; + case 507: jj_3_508(); break; + case 508: jj_3_509(); break; + case 509: jj_3_510(); break; + case 510: jj_3_511(); break; + case 511: jj_3_512(); break; + case 512: jj_3_513(); break; + case 513: jj_3_514(); break; + case 514: jj_3_515(); break; + case 515: jj_3_516(); break; + case 516: jj_3_517(); break; + case 517: jj_3_518(); break; + case 518: jj_3_519(); break; + case 519: jj_3_520(); break; + case 520: jj_3_521(); break; + case 521: jj_3_522(); break; + case 522: jj_3_523(); break; + case 523: jj_3_524(); break; + case 524: jj_3_525(); break; + case 525: jj_3_526(); break; + case 526: jj_3_527(); break; + case 527: jj_3_528(); break; + case 528: jj_3_529(); break; + case 529: jj_3_530(); break; + case 530: jj_3_531(); break; + case 531: jj_3_532(); break; + case 532: jj_3_533(); break; + case 533: jj_3_534(); break; + case 534: jj_3_535(); break; + case 535: jj_3_536(); break; + case 536: jj_3_537(); break; + case 537: jj_3_538(); break; + case 538: jj_3_539(); break; + case 539: jj_3_540(); break; + case 540: jj_3_541(); break; + case 541: jj_3_542(); break; + case 542: jj_3_543(); break; + case 543: jj_3_544(); break; + case 544: jj_3_545(); break; + case 545: jj_3_546(); break; + case 546: jj_3_547(); break; + case 547: jj_3_548(); break; + case 548: jj_3_549(); break; + case 549: jj_3_550(); break; + case 550: jj_3_551(); break; + case 551: jj_3_552(); break; + case 552: jj_3_553(); break; + case 553: jj_3_554(); break; + case 554: jj_3_555(); break; + case 555: jj_3_556(); break; + case 556: jj_3_557(); break; + case 557: jj_3_558(); break; + case 558: jj_3_559(); break; + case 559: jj_3_560(); break; + case 560: jj_3_561(); break; + case 561: jj_3_562(); break; + case 562: jj_3_563(); break; + case 563: jj_3_564(); break; + case 564: jj_3_565(); break; + case 565: jj_3_566(); break; + case 566: jj_3_567(); break; + case 567: jj_3_568(); break; + case 568: jj_3_569(); break; + case 569: jj_3_570(); break; + case 570: jj_3_571(); break; + case 571: jj_3_572(); break; + case 572: jj_3_573(); break; + case 573: jj_3_574(); break; + case 574: jj_3_575(); break; + case 575: jj_3_576(); break; + case 576: jj_3_577(); break; + case 577: jj_3_578(); break; + case 578: jj_3_579(); break; + case 579: jj_3_580(); break; + case 580: jj_3_581(); break; + case 581: jj_3_582(); break; + case 582: jj_3_583(); break; + case 583: jj_3_584(); break; + case 584: jj_3_585(); break; + case 585: jj_3_586(); break; + case 586: jj_3_587(); break; + case 587: jj_3_588(); break; + case 588: jj_3_589(); break; + case 589: jj_3_590(); break; + case 590: jj_3_591(); break; + case 591: jj_3_592(); break; + case 592: jj_3_593(); break; + case 593: jj_3_594(); break; + case 594: jj_3_595(); break; + case 595: jj_3_596(); break; + case 596: jj_3_597(); break; + case 597: jj_3_598(); break; + case 598: jj_3_599(); break; + case 599: jj_3_600(); break; + case 600: jj_3_601(); break; + case 601: jj_3_602(); break; + case 602: jj_3_603(); break; + case 603: jj_3_604(); break; + case 604: jj_3_605(); break; + case 605: jj_3_606(); break; + case 606: jj_3_607(); break; + case 607: jj_3_608(); break; + case 608: jj_3_609(); break; + case 609: jj_3_610(); break; + case 610: jj_3_611(); break; + case 611: jj_3_612(); break; + case 612: jj_3_613(); break; + case 613: jj_3_614(); break; + case 614: jj_3_615(); break; + case 615: jj_3_616(); break; + case 616: jj_3_617(); break; + case 617: jj_3_618(); break; + case 618: jj_3_619(); break; + case 619: jj_3_620(); break; + case 620: jj_3_621(); break; + case 621: jj_3_622(); break; + case 622: jj_3_623(); break; + case 623: jj_3_624(); break; + case 624: jj_3_625(); break; + case 625: jj_3_626(); break; + case 626: jj_3_627(); break; + case 627: jj_3_628(); break; + case 628: jj_3_629(); break; + case 629: jj_3_630(); break; + case 630: jj_3_631(); break; + case 631: jj_3_632(); break; + case 632: jj_3_633(); break; + case 633: jj_3_634(); break; + case 634: jj_3_635(); break; + case 635: jj_3_636(); break; + case 636: jj_3_637(); break; + case 637: jj_3_638(); break; + case 638: jj_3_639(); break; + case 639: jj_3_640(); break; + case 640: jj_3_641(); break; + case 641: jj_3_642(); break; + case 642: jj_3_643(); break; + case 643: jj_3_644(); break; + case 644: jj_3_645(); break; + case 645: jj_3_646(); break; + case 646: jj_3_647(); break; + case 647: jj_3_648(); break; + case 648: jj_3_649(); break; + case 649: jj_3_650(); break; + case 650: jj_3_651(); break; + case 651: jj_3_652(); break; + case 652: jj_3_653(); break; + case 653: jj_3_654(); break; + case 654: jj_3_655(); break; + case 655: jj_3_656(); break; + case 656: jj_3_657(); break; + case 657: jj_3_658(); break; + case 658: jj_3_659(); break; + case 659: jj_3_660(); break; + case 660: jj_3_661(); break; + case 661: jj_3_662(); break; + case 662: jj_3_663(); break; + case 663: jj_3_664(); break; + case 664: jj_3_665(); break; + case 665: jj_3_666(); break; + case 666: jj_3_667(); break; + case 667: jj_3_668(); break; + case 668: jj_3_669(); break; + case 669: jj_3_670(); break; + case 670: jj_3_671(); break; + case 671: jj_3_672(); break; + case 672: jj_3_673(); break; + case 673: jj_3_674(); break; + case 674: jj_3_675(); break; + case 675: jj_3_676(); break; + case 676: jj_3_677(); break; + case 677: jj_3_678(); break; + case 678: jj_3_679(); break; + case 679: jj_3_680(); break; + case 680: jj_3_681(); break; + case 681: jj_3_682(); break; + case 682: jj_3_683(); break; + case 683: jj_3_684(); break; + case 684: jj_3_685(); break; + case 685: jj_3_686(); break; + case 686: jj_3_687(); break; + case 687: jj_3_688(); break; + case 688: jj_3_689(); break; + case 689: jj_3_690(); break; + case 690: jj_3_691(); break; + case 691: jj_3_692(); break; + case 692: jj_3_693(); break; + case 693: jj_3_694(); break; + case 694: jj_3_695(); break; + case 695: jj_3_696(); break; + case 696: jj_3_697(); break; + case 697: jj_3_698(); break; + case 698: jj_3_699(); break; + case 699: jj_3_700(); break; + case 700: jj_3_701(); break; + case 701: jj_3_702(); break; + case 702: jj_3_703(); break; + case 703: jj_3_704(); break; + case 704: jj_3_705(); break; + case 705: jj_3_706(); break; + case 706: jj_3_707(); break; + case 707: jj_3_708(); break; + case 708: jj_3_709(); break; + case 709: jj_3_710(); break; + case 710: jj_3_711(); break; + case 711: jj_3_712(); break; + case 712: jj_3_713(); break; + case 713: jj_3_714(); break; + case 714: jj_3_715(); break; + case 715: jj_3_716(); break; + case 716: jj_3_717(); break; + case 717: jj_3_718(); break; + case 718: jj_3_719(); break; + case 719: jj_3_720(); break; + case 720: jj_3_721(); break; + case 721: jj_3_722(); break; + case 722: jj_3_723(); break; + case 723: jj_3_724(); break; + case 724: jj_3_725(); break; + case 725: jj_3_726(); break; + case 726: jj_3_727(); break; + case 727: jj_3_728(); break; + case 728: jj_3_729(); break; + case 729: jj_3_730(); break; + case 730: jj_3_731(); break; + case 731: jj_3_732(); break; + case 732: jj_3_733(); break; + case 733: jj_3_734(); break; + case 734: jj_3_735(); break; + case 735: jj_3_736(); break; + case 736: jj_3_737(); break; + case 737: jj_3_738(); break; + case 738: jj_3_739(); break; + case 739: jj_3_740(); break; + case 740: jj_3_741(); break; + case 741: jj_3_742(); break; + case 742: jj_3_743(); break; + case 743: jj_3_744(); break; + case 744: jj_3_745(); break; + case 745: jj_3_746(); break; + case 746: jj_3_747(); break; + case 747: jj_3_748(); break; + case 748: jj_3_749(); break; + case 749: jj_3_750(); break; + case 750: jj_3_751(); break; + case 751: jj_3_752(); break; + case 752: jj_3_753(); break; + case 753: jj_3_754(); break; + case 754: jj_3_755(); break; + case 755: jj_3_756(); break; + case 756: jj_3_757(); break; + case 757: jj_3_758(); break; + case 758: jj_3_759(); break; + case 759: jj_3_760(); break; + case 760: jj_3_761(); break; + case 761: jj_3_762(); break; + case 762: jj_3_763(); break; + case 763: jj_3_764(); break; + case 764: jj_3_765(); break; + case 765: jj_3_766(); break; + case 766: jj_3_767(); break; + case 767: jj_3_768(); break; + case 768: jj_3_769(); break; + case 769: jj_3_770(); break; + case 770: jj_3_771(); break; + case 771: jj_3_772(); break; + case 772: jj_3_773(); break; + case 773: jj_3_774(); break; + case 774: jj_3_775(); break; + case 775: jj_3_776(); break; + case 776: jj_3_777(); break; + case 777: jj_3_778(); break; + case 778: jj_3_779(); break; + case 779: jj_3_780(); break; + case 780: jj_3_781(); break; + case 781: jj_3_782(); break; + case 782: jj_3_783(); break; + case 783: jj_3_784(); break; + case 784: jj_3_785(); break; + case 785: jj_3_786(); break; + case 786: jj_3_787(); break; + case 787: jj_3_788(); break; + case 788: jj_3_789(); break; + case 789: jj_3_790(); break; + case 790: jj_3_791(); break; + case 791: jj_3_792(); break; + case 792: jj_3_793(); break; + case 793: jj_3_794(); break; + case 794: jj_3_795(); break; + case 795: jj_3_796(); break; + case 796: jj_3_797(); break; + case 797: jj_3_798(); break; + case 798: jj_3_799(); break; + case 799: jj_3_800(); break; + case 800: jj_3_801(); break; + case 801: jj_3_802(); break; + case 802: jj_3_803(); break; + case 803: jj_3_804(); break; + case 804: jj_3_805(); break; + case 805: jj_3_806(); break; + case 806: jj_3_807(); break; + case 807: jj_3_808(); break; + case 808: jj_3_809(); break; + case 809: jj_3_810(); break; + case 810: jj_3_811(); break; + case 811: jj_3_812(); break; + case 812: jj_3_813(); break; + case 813: jj_3_814(); break; + case 814: jj_3_815(); break; + case 815: jj_3_816(); break; + case 816: jj_3_817(); break; + case 817: jj_3_818(); break; + case 818: jj_3_819(); break; + case 819: jj_3_820(); break; + case 820: jj_3_821(); break; + case 821: jj_3_822(); break; + case 822: jj_3_823(); break; + case 823: jj_3_824(); break; + case 824: jj_3_825(); break; + case 825: jj_3_826(); break; + case 826: jj_3_827(); break; + case 827: jj_3_828(); break; + case 828: jj_3_829(); break; + case 829: jj_3_830(); break; + case 830: jj_3_831(); break; + case 831: jj_3_832(); break; + case 832: jj_3_833(); break; + case 833: jj_3_834(); break; + case 834: jj_3_835(); break; + case 835: jj_3_836(); break; + case 836: jj_3_837(); break; + case 837: jj_3_838(); break; + case 838: jj_3_839(); break; + case 839: jj_3_840(); break; + case 840: jj_3_841(); break; + case 841: jj_3_842(); break; + case 842: jj_3_843(); break; + case 843: jj_3_844(); break; + case 844: jj_3_845(); break; + case 845: jj_3_846(); break; + case 846: jj_3_847(); break; + case 847: jj_3_848(); break; + case 848: jj_3_849(); break; + case 849: jj_3_850(); break; + case 850: jj_3_851(); break; + case 851: jj_3_852(); break; + case 852: jj_3_853(); break; + case 853: jj_3_854(); break; + case 854: jj_3_855(); break; + case 855: jj_3_856(); break; + case 856: jj_3_857(); break; + case 857: jj_3_858(); break; + case 858: jj_3_859(); break; + case 859: jj_3_860(); break; + case 860: jj_3_861(); break; + case 861: jj_3_862(); break; + case 862: jj_3_863(); break; + case 863: jj_3_864(); break; + case 864: jj_3_865(); break; + case 865: jj_3_866(); break; + case 866: jj_3_867(); break; + case 867: jj_3_868(); break; + case 868: jj_3_869(); break; + case 869: jj_3_870(); break; + case 870: jj_3_871(); break; + case 871: jj_3_872(); break; + case 872: jj_3_873(); break; + case 873: jj_3_874(); break; + case 874: jj_3_875(); break; + case 875: jj_3_876(); break; + case 876: jj_3_877(); break; + case 877: jj_3_878(); break; + case 878: jj_3_879(); break; + case 879: jj_3_880(); break; + case 880: jj_3_881(); break; + case 881: jj_3_882(); break; + case 882: jj_3_883(); break; + case 883: jj_3_884(); break; + case 884: jj_3_885(); break; + case 885: jj_3_886(); break; + case 886: jj_3_887(); break; + case 887: jj_3_888(); break; + case 888: jj_3_889(); break; + case 889: jj_3_890(); break; + case 890: jj_3_891(); break; + case 891: jj_3_892(); break; + case 892: jj_3_893(); break; + case 893: jj_3_894(); break; + case 894: jj_3_895(); break; + case 895: jj_3_896(); break; + case 896: jj_3_897(); break; + case 897: jj_3_898(); break; + case 898: jj_3_899(); break; + case 899: jj_3_900(); break; + case 900: jj_3_901(); break; + case 901: jj_3_902(); break; + case 902: jj_3_903(); break; + case 903: jj_3_904(); break; + case 904: jj_3_905(); break; + case 905: jj_3_906(); break; + case 906: jj_3_907(); break; + case 907: jj_3_908(); break; + case 908: jj_3_909(); break; + case 909: jj_3_910(); break; + case 910: jj_3_911(); break; + case 911: jj_3_912(); break; + case 912: jj_3_913(); break; + case 913: jj_3_914(); break; + case 914: jj_3_915(); break; + case 915: jj_3_916(); break; + case 916: jj_3_917(); break; + case 917: jj_3_918(); break; + case 918: jj_3_919(); break; + case 919: jj_3_920(); break; + case 920: jj_3_921(); break; + case 921: jj_3_922(); break; + case 922: jj_3_923(); break; + case 923: jj_3_924(); break; + case 924: jj_3_925(); break; + case 925: jj_3_926(); break; + case 926: jj_3_927(); break; + case 927: jj_3_928(); break; + case 928: jj_3_929(); break; + case 929: jj_3_930(); break; + case 930: jj_3_931(); break; + case 931: jj_3_932(); break; + case 932: jj_3_933(); break; + case 933: jj_3_934(); break; + case 934: jj_3_935(); break; + case 935: jj_3_936(); break; + case 936: jj_3_937(); break; + case 937: jj_3_938(); break; + case 938: jj_3_939(); break; + case 939: jj_3_940(); break; + case 940: jj_3_941(); break; + case 941: jj_3_942(); break; + case 942: jj_3_943(); break; + case 943: jj_3_944(); break; + case 944: jj_3_945(); break; + case 945: jj_3_946(); break; + case 946: jj_3_947(); break; + case 947: jj_3_948(); break; + case 948: jj_3_949(); break; + case 949: jj_3_950(); break; + case 950: jj_3_951(); break; + case 951: jj_3_952(); break; + case 952: jj_3_953(); break; + case 953: jj_3_954(); break; + case 954: jj_3_955(); break; + case 955: jj_3_956(); break; + case 956: jj_3_957(); break; + case 957: jj_3_958(); break; + case 958: jj_3_959(); break; + case 959: jj_3_960(); break; + case 960: jj_3_961(); break; + case 961: jj_3_962(); break; + case 962: jj_3_963(); break; + case 963: jj_3_964(); break; + case 964: jj_3_965(); break; + case 965: jj_3_966(); break; + case 966: jj_3_967(); break; + case 967: jj_3_968(); break; + case 968: jj_3_969(); break; + case 969: jj_3_970(); break; + case 970: jj_3_971(); break; + case 971: jj_3_972(); break; + case 972: jj_3_973(); break; + case 973: jj_3_974(); break; + case 974: jj_3_975(); break; + case 975: jj_3_976(); break; + case 976: jj_3_977(); break; + case 977: jj_3_978(); break; + case 978: jj_3_979(); break; + case 979: jj_3_980(); break; + case 980: jj_3_981(); break; + case 981: jj_3_982(); break; + case 982: jj_3_983(); break; + case 983: jj_3_984(); break; + case 984: jj_3_985(); break; + case 985: jj_3_986(); break; + case 986: jj_3_987(); break; + case 987: jj_3_988(); break; + case 988: jj_3_989(); break; + case 989: jj_3_990(); break; + case 990: jj_3_991(); break; + case 991: jj_3_992(); break; + case 992: jj_3_993(); break; + case 993: jj_3_994(); break; + case 994: jj_3_995(); break; + case 995: jj_3_996(); break; + case 996: jj_3_997(); break; + case 997: jj_3_998(); break; + case 998: jj_3_999(); break; + case 999: jj_3_1000(); break; + case 1000: jj_3_1001(); break; + case 1001: jj_3_1002(); break; + case 1002: jj_3_1003(); break; + case 1003: jj_3_1004(); break; + case 1004: jj_3_1005(); break; + case 1005: jj_3_1006(); break; + case 1006: jj_3_1007(); break; + case 1007: jj_3_1008(); break; + case 1008: jj_3_1009(); break; + case 1009: jj_3_1010(); break; + case 1010: jj_3_1011(); break; + case 1011: jj_3_1012(); break; + case 1012: jj_3_1013(); break; + case 1013: jj_3_1014(); break; + case 1014: jj_3_1015(); break; + case 1015: jj_3_1016(); break; + case 1016: jj_3_1017(); break; + case 1017: jj_3_1018(); break; + case 1018: jj_3_1019(); break; + case 1019: jj_3_1020(); break; + case 1020: jj_3_1021(); break; + case 1021: jj_3_1022(); break; + case 1022: jj_3_1023(); break; + case 1023: jj_3_1024(); break; + case 1024: jj_3_1025(); break; + case 1025: jj_3_1026(); break; + case 1026: jj_3_1027(); break; + case 1027: jj_3_1028(); break; + case 1028: jj_3_1029(); break; + case 1029: jj_3_1030(); break; + case 1030: jj_3_1031(); break; + case 1031: jj_3_1032(); break; + case 1032: jj_3_1033(); break; + case 1033: jj_3_1034(); break; + case 1034: jj_3_1035(); break; + case 1035: jj_3_1036(); break; + case 1036: jj_3_1037(); break; + case 1037: jj_3_1038(); break; + case 1038: jj_3_1039(); break; + case 1039: jj_3_1040(); break; + case 1040: jj_3_1041(); break; + case 1041: jj_3_1042(); break; + case 1042: jj_3_1043(); break; + case 1043: jj_3_1044(); break; + case 1044: jj_3_1045(); break; + case 1045: jj_3_1046(); break; + case 1046: jj_3_1047(); break; + case 1047: jj_3_1048(); break; + case 1048: jj_3_1049(); break; + case 1049: jj_3_1050(); break; + case 1050: jj_3_1051(); break; + case 1051: jj_3_1052(); break; + case 1052: jj_3_1053(); break; + case 1053: jj_3_1054(); break; + case 1054: jj_3_1055(); break; + case 1055: jj_3_1056(); break; + case 1056: jj_3_1057(); break; + case 1057: jj_3_1058(); break; + case 1058: jj_3_1059(); break; + case 1059: jj_3_1060(); break; + case 1060: jj_3_1061(); break; + case 1061: jj_3_1062(); break; + case 1062: jj_3_1063(); break; + case 1063: jj_3_1064(); break; + case 1064: jj_3_1065(); break; + case 1065: jj_3_1066(); break; + case 1066: jj_3_1067(); break; + case 1067: jj_3_1068(); break; + case 1068: jj_3_1069(); break; + case 1069: jj_3_1070(); break; + case 1070: jj_3_1071(); break; + case 1071: jj_3_1072(); break; + case 1072: jj_3_1073(); break; + case 1073: jj_3_1074(); break; + case 1074: jj_3_1075(); break; + case 1075: jj_3_1076(); break; + case 1076: jj_3_1077(); break; + case 1077: jj_3_1078(); break; + case 1078: jj_3_1079(); break; + case 1079: jj_3_1080(); break; + case 1080: jj_3_1081(); break; + case 1081: jj_3_1082(); break; + case 1082: jj_3_1083(); break; + case 1083: jj_3_1084(); break; + case 1084: jj_3_1085(); break; + case 1085: jj_3_1086(); break; + case 1086: jj_3_1087(); break; + case 1087: jj_3_1088(); break; + case 1088: jj_3_1089(); break; + case 1089: jj_3_1090(); break; + case 1090: jj_3_1091(); break; + case 1091: jj_3_1092(); break; + case 1092: jj_3_1093(); break; + case 1093: jj_3_1094(); break; + case 1094: jj_3_1095(); break; + case 1095: jj_3_1096(); break; + case 1096: jj_3_1097(); break; + case 1097: jj_3_1098(); break; + case 1098: jj_3_1099(); break; + case 1099: jj_3_1100(); break; + case 1100: jj_3_1101(); break; + case 1101: jj_3_1102(); break; + case 1102: jj_3_1103(); break; + case 1103: jj_3_1104(); break; + case 1104: jj_3_1105(); break; + case 1105: jj_3_1106(); break; + case 1106: jj_3_1107(); break; + case 1107: jj_3_1108(); break; + case 1108: jj_3_1109(); break; + case 1109: jj_3_1110(); break; + case 1110: jj_3_1111(); break; + case 1111: jj_3_1112(); break; + case 1112: jj_3_1113(); break; + case 1113: jj_3_1114(); break; + case 1114: jj_3_1115(); break; + case 1115: jj_3_1116(); break; + case 1116: jj_3_1117(); break; + case 1117: jj_3_1118(); break; + case 1118: jj_3_1119(); break; + case 1119: jj_3_1120(); break; + case 1120: jj_3_1121(); break; + case 1121: jj_3_1122(); break; + case 1122: jj_3_1123(); break; + case 1123: jj_3_1124(); break; + case 1124: jj_3_1125(); break; + case 1125: jj_3_1126(); break; + case 1126: jj_3_1127(); break; + case 1127: jj_3_1128(); break; + case 1128: jj_3_1129(); break; + case 1129: jj_3_1130(); break; + case 1130: jj_3_1131(); break; + case 1131: jj_3_1132(); break; + case 1132: jj_3_1133(); break; + case 1133: jj_3_1134(); break; + case 1134: jj_3_1135(); break; + case 1135: jj_3_1136(); break; + case 1136: jj_3_1137(); break; + case 1137: jj_3_1138(); break; + case 1138: jj_3_1139(); break; + case 1139: jj_3_1140(); break; + case 1140: jj_3_1141(); break; + case 1141: jj_3_1142(); break; + case 1142: jj_3_1143(); break; + case 1143: jj_3_1144(); break; + case 1144: jj_3_1145(); break; + case 1145: jj_3_1146(); break; + case 1146: jj_3_1147(); break; + case 1147: jj_3_1148(); break; + case 1148: jj_3_1149(); break; + case 1149: jj_3_1150(); break; + case 1150: jj_3_1151(); break; + case 1151: jj_3_1152(); break; + case 1152: jj_3_1153(); break; + case 1153: jj_3_1154(); break; + case 1154: jj_3_1155(); break; + case 1155: jj_3_1156(); break; + case 1156: jj_3_1157(); break; + case 1157: jj_3_1158(); break; + case 1158: jj_3_1159(); break; + case 1159: jj_3_1160(); break; + case 1160: jj_3_1161(); break; + case 1161: jj_3_1162(); break; + case 1162: jj_3_1163(); break; + case 1163: jj_3_1164(); break; + case 1164: jj_3_1165(); break; + case 1165: jj_3_1166(); break; + case 1166: jj_3_1167(); break; + case 1167: jj_3_1168(); break; + case 1168: jj_3_1169(); break; + case 1169: jj_3_1170(); break; + case 1170: jj_3_1171(); break; + case 1171: jj_3_1172(); break; + case 1172: jj_3_1173(); break; + case 1173: jj_3_1174(); break; + case 1174: jj_3_1175(); break; + case 1175: jj_3_1176(); break; + case 1176: jj_3_1177(); break; + case 1177: jj_3_1178(); break; + case 1178: jj_3_1179(); break; + case 1179: jj_3_1180(); break; + case 1180: jj_3_1181(); break; + case 1181: jj_3_1182(); break; + case 1182: jj_3_1183(); break; + case 1183: jj_3_1184(); break; + case 1184: jj_3_1185(); break; + case 1185: jj_3_1186(); break; + case 1186: jj_3_1187(); break; + case 1187: jj_3_1188(); break; + case 1188: jj_3_1189(); break; + case 1189: jj_3_1190(); break; + case 1190: jj_3_1191(); break; + case 1191: jj_3_1192(); break; + case 1192: jj_3_1193(); break; + case 1193: jj_3_1194(); break; + case 1194: jj_3_1195(); break; + case 1195: jj_3_1196(); break; + case 1196: jj_3_1197(); break; + case 1197: jj_3_1198(); break; + case 1198: jj_3_1199(); break; + case 1199: jj_3_1200(); break; + case 1200: jj_3_1201(); break; + case 1201: jj_3_1202(); break; + case 1202: jj_3_1203(); break; + case 1203: jj_3_1204(); break; + case 1204: jj_3_1205(); break; + case 1205: jj_3_1206(); break; + case 1206: jj_3_1207(); break; + case 1207: jj_3_1208(); break; + case 1208: jj_3_1209(); break; + case 1209: jj_3_1210(); break; + case 1210: jj_3_1211(); break; + case 1211: jj_3_1212(); break; + case 1212: jj_3_1213(); break; + case 1213: jj_3_1214(); break; + case 1214: jj_3_1215(); break; + case 1215: jj_3_1216(); break; + case 1216: jj_3_1217(); break; + case 1217: jj_3_1218(); break; + case 1218: jj_3_1219(); break; + case 1219: jj_3_1220(); break; + case 1220: jj_3_1221(); break; + case 1221: jj_3_1222(); break; + case 1222: jj_3_1223(); break; + case 1223: jj_3_1224(); break; + case 1224: jj_3_1225(); break; + case 1225: jj_3_1226(); break; + case 1226: jj_3_1227(); break; + case 1227: jj_3_1228(); break; + case 1228: jj_3_1229(); break; + case 1229: jj_3_1230(); break; + case 1230: jj_3_1231(); break; + case 1231: jj_3_1232(); break; + case 1232: jj_3_1233(); break; + case 1233: jj_3_1234(); break; + case 1234: jj_3_1235(); break; + case 1235: jj_3_1236(); break; + case 1236: jj_3_1237(); break; + case 1237: jj_3_1238(); break; + case 1238: jj_3_1239(); break; + case 1239: jj_3_1240(); break; + case 1240: jj_3_1241(); break; + case 1241: jj_3_1242(); break; + case 1242: jj_3_1243(); break; + case 1243: jj_3_1244(); break; + case 1244: jj_3_1245(); break; + case 1245: jj_3_1246(); break; + case 1246: jj_3_1247(); break; + case 1247: jj_3_1248(); break; + case 1248: jj_3_1249(); break; + case 1249: jj_3_1250(); break; + case 1250: jj_3_1251(); break; + case 1251: jj_3_1252(); break; + case 1252: jj_3_1253(); break; + case 1253: jj_3_1254(); break; + case 1254: jj_3_1255(); break; + case 1255: jj_3_1256(); break; + case 1256: jj_3_1257(); break; + case 1257: jj_3_1258(); break; + case 1258: jj_3_1259(); break; + case 1259: jj_3_1260(); break; + case 1260: jj_3_1261(); break; + case 1261: jj_3_1262(); break; + case 1262: jj_3_1263(); break; + case 1263: jj_3_1264(); break; + case 1264: jj_3_1265(); break; + case 1265: jj_3_1266(); break; + case 1266: jj_3_1267(); break; + case 1267: jj_3_1268(); break; + case 1268: jj_3_1269(); break; + case 1269: jj_3_1270(); break; + case 1270: jj_3_1271(); break; + case 1271: jj_3_1272(); break; + case 1272: jj_3_1273(); break; + case 1273: jj_3_1274(); break; + case 1274: jj_3_1275(); break; + case 1275: jj_3_1276(); break; + case 1276: jj_3_1277(); break; + case 1277: jj_3_1278(); break; + case 1278: jj_3_1279(); break; + case 1279: jj_3_1280(); break; + case 1280: jj_3_1281(); break; + case 1281: jj_3_1282(); break; + case 1282: jj_3_1283(); break; + case 1283: jj_3_1284(); break; + case 1284: jj_3_1285(); break; + case 1285: jj_3_1286(); break; + case 1286: jj_3_1287(); break; + case 1287: jj_3_1288(); break; + case 1288: jj_3_1289(); break; + case 1289: jj_3_1290(); break; + case 1290: jj_3_1291(); break; + case 1291: jj_3_1292(); break; + case 1292: jj_3_1293(); break; + case 1293: jj_3_1294(); break; + case 1294: jj_3_1295(); break; + case 1295: jj_3_1296(); break; + case 1296: jj_3_1297(); break; + case 1297: jj_3_1298(); break; + case 1298: jj_3_1299(); break; + case 1299: jj_3_1300(); break; + case 1300: jj_3_1301(); break; + case 1301: jj_3_1302(); break; + case 1302: jj_3_1303(); break; + case 1303: jj_3_1304(); break; + case 1304: jj_3_1305(); break; + case 1305: jj_3_1306(); break; + case 1306: jj_3_1307(); break; + case 1307: jj_3_1308(); break; + case 1308: jj_3_1309(); break; + case 1309: jj_3_1310(); break; + case 1310: jj_3_1311(); break; + case 1311: jj_3_1312(); break; + case 1312: jj_3_1313(); break; + case 1313: jj_3_1314(); break; + case 1314: jj_3_1315(); break; + case 1315: jj_3_1316(); break; + case 1316: jj_3_1317(); break; + case 1317: jj_3_1318(); break; + case 1318: jj_3_1319(); break; + case 1319: jj_3_1320(); break; + case 1320: jj_3_1321(); break; + case 1321: jj_3_1322(); break; + case 1322: jj_3_1323(); break; + case 1323: jj_3_1324(); break; + case 1324: jj_3_1325(); break; + case 1325: jj_3_1326(); break; + case 1326: jj_3_1327(); break; + case 1327: jj_3_1328(); break; + case 1328: jj_3_1329(); break; + case 1329: jj_3_1330(); break; + case 1330: jj_3_1331(); break; + case 1331: jj_3_1332(); break; + case 1332: jj_3_1333(); break; + case 1333: jj_3_1334(); break; + case 1334: jj_3_1335(); break; + case 1335: jj_3_1336(); break; + case 1336: jj_3_1337(); break; + case 1337: jj_3_1338(); break; + case 1338: jj_3_1339(); break; + case 1339: jj_3_1340(); break; + case 1340: jj_3_1341(); break; + case 1341: jj_3_1342(); break; + case 1342: jj_3_1343(); break; + case 1343: jj_3_1344(); break; + case 1344: jj_3_1345(); break; + case 1345: jj_3_1346(); break; + case 1346: jj_3_1347(); break; + case 1347: jj_3_1348(); break; + case 1348: jj_3_1349(); break; + case 1349: jj_3_1350(); break; + case 1350: jj_3_1351(); break; + case 1351: jj_3_1352(); break; + case 1352: jj_3_1353(); break; + case 1353: jj_3_1354(); break; + case 1354: jj_3_1355(); break; + case 1355: jj_3_1356(); break; + case 1356: jj_3_1357(); break; + case 1357: jj_3_1358(); break; + case 1358: jj_3_1359(); break; + case 1359: jj_3_1360(); break; + case 1360: jj_3_1361(); break; + case 1361: jj_3_1362(); break; + case 1362: jj_3_1363(); break; + case 1363: jj_3_1364(); break; + case 1364: jj_3_1365(); break; + case 1365: jj_3_1366(); break; + case 1366: jj_3_1367(); break; + case 1367: jj_3_1368(); break; + case 1368: jj_3_1369(); break; + case 1369: jj_3_1370(); break; + case 1370: jj_3_1371(); break; + case 1371: jj_3_1372(); break; + case 1372: jj_3_1373(); break; + case 1373: jj_3_1374(); break; + case 1374: jj_3_1375(); break; + case 1375: jj_3_1376(); break; + case 1376: jj_3_1377(); break; + case 1377: jj_3_1378(); break; + case 1378: jj_3_1379(); break; + case 1379: jj_3_1380(); break; + case 1380: jj_3_1381(); break; + case 1381: jj_3_1382(); break; + case 1382: jj_3_1383(); break; + case 1383: jj_3_1384(); break; + case 1384: jj_3_1385(); break; + case 1385: jj_3_1386(); break; + case 1386: jj_3_1387(); break; + case 1387: jj_3_1388(); break; + case 1388: jj_3_1389(); break; + case 1389: jj_3_1390(); break; + case 1390: jj_3_1391(); break; + case 1391: jj_3_1392(); break; + case 1392: jj_3_1393(); break; + case 1393: jj_3_1394(); break; + case 1394: jj_3_1395(); break; + case 1395: jj_3_1396(); break; + case 1396: jj_3_1397(); break; + case 1397: jj_3_1398(); break; + case 1398: jj_3_1399(); break; + case 1399: jj_3_1400(); break; + case 1400: jj_3_1401(); break; + } + } + p = p.next; + } while (p != null); + } catch(LookaheadSuccess ls) { } + } + jj_rescan = false; + } + + final private void jj_save(int index, int xla) { + JJCalls p = jj_2_rtns[index]; + while (p.gen > jj_gen) { + if (p.next == null) { p = p.next = new JJCalls(); break; } + p = p.next; + } + p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; + } + + static final class JJCalls { + int gen; + Token first; + int arg; + JJCalls next; + } + +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplConstants.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplConstants.java new file mode 100644 index 0000000000000..000001e09041e --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplConstants.java @@ -0,0 +1,1584 @@ +/* Generated By:JavaCC: Do not edit this line. IgniteSqlParserImplConstants.java */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +public interface IgniteSqlParserImplConstants { + + int EOF = 0; + int NEGATE = 1; + int TILDE = 2; + int A = 3; + int ABS = 4; + int ABSENT = 5; + int ABSOLUTE = 6; + int ACTION = 7; + int ADA = 8; + int ADD = 9; + int ADMIN = 10; + int AFTER = 11; + int ALL = 12; + int ALLOCATE = 13; + int ALLOW = 14; + int ALTER = 15; + int ALWAYS = 16; + int AND = 17; + int ANY = 18; + int APPLY = 19; + int ARE = 20; + int ARRAY = 21; + int ARRAY_AGG = 22; + int ARRAY_CONCAT_AGG = 23; + int ARRAY_MAX_CARDINALITY = 24; + int AS = 25; + int ASC = 26; + int ASENSITIVE = 27; + int ASSERTION = 28; + int ASSIGNMENT = 29; + int ASYMMETRIC = 30; + int AT = 31; + int ATOMIC = 32; + int ATTRIBUTE = 33; + int ATTRIBUTES = 34; + int AUTHORIZATION = 35; + int AVG = 36; + int BEFORE = 37; + int BEGIN = 38; + int BEGIN_FRAME = 39; + int BEGIN_PARTITION = 40; + int BERNOULLI = 41; + int BETWEEN = 42; + int BIGINT = 43; + int BINARY = 44; + int BIT = 45; + int BLOB = 46; + int BOOLEAN = 47; + int BOTH = 48; + int BREADTH = 49; + int BY = 50; + int C = 51; + int CALL = 52; + int CALLED = 53; + int CARDINALITY = 54; + int CASCADE = 55; + int CASCADED = 56; + int CASE = 57; + int CAST = 58; + int CATALOG = 59; + int CATALOG_NAME = 60; + int CEIL = 61; + int CEILING = 62; + int CENTURY = 63; + int CHAIN = 64; + int CHAR = 65; + int CHAR_LENGTH = 66; + int CHARACTER = 67; + int CHARACTER_LENGTH = 68; + int CHARACTER_SET_CATALOG = 69; + int CHARACTER_SET_NAME = 70; + int CHARACTER_SET_SCHEMA = 71; + int CHARACTERISTICS = 72; + int CHARACTERS = 73; + int CHECK = 74; + int CLASSIFIER = 75; + int CLASS_ORIGIN = 76; + int CLOB = 77; + int CLOSE = 78; + int COALESCE = 79; + int COBOL = 80; + int COLLATE = 81; + int COLLATION = 82; + int COLLATION_CATALOG = 83; + int COLLATION_NAME = 84; + int COLLATION_SCHEMA = 85; + int COLLECT = 86; + int COLUMN = 87; + int COLUMN_NAME = 88; + int COMMAND_FUNCTION = 89; + int COMMAND_FUNCTION_CODE = 90; + int COMMIT = 91; + int COMMITTED = 92; + int CONDITION = 93; + int CONDITIONAL = 94; + int CONDITION_NUMBER = 95; + int CONNECT = 96; + int CONNECTION = 97; + int CONNECTION_NAME = 98; + int CONSTRAINT = 99; + int CONSTRAINT_CATALOG = 100; + int CONSTRAINT_NAME = 101; + int CONSTRAINT_SCHEMA = 102; + int CONSTRAINTS = 103; + int CONSTRUCTOR = 104; + int CONTAINS = 105; + int CONTINUE = 106; + int CONVERT = 107; + int CORR = 108; + int CORRESPONDING = 109; + int COUNT = 110; + int COVAR_POP = 111; + int COVAR_SAMP = 112; + int CREATE = 113; + int CROSS = 114; + int CUBE = 115; + int CUME_DIST = 116; + int CURRENT = 117; + int CURRENT_CATALOG = 118; + int CURRENT_DATE = 119; + int CURRENT_DEFAULT_TRANSFORM_GROUP = 120; + int CURRENT_PATH = 121; + int CURRENT_ROLE = 122; + int CURRENT_ROW = 123; + int CURRENT_SCHEMA = 124; + int CURRENT_TIME = 125; + int CURRENT_TIMESTAMP = 126; + int CURRENT_TRANSFORM_GROUP_FOR_TYPE = 127; + int CURRENT_USER = 128; + int CURSOR = 129; + int CURSOR_NAME = 130; + int CYCLE = 131; + int DATA = 132; + int DATABASE = 133; + int DATE = 134; + int DATETIME_INTERVAL_CODE = 135; + int DATETIME_INTERVAL_PRECISION = 136; + int DAY = 137; + int DAYS = 138; + int DEALLOCATE = 139; + int DEC = 140; + int DECADE = 141; + int DECIMAL = 142; + int DECLARE = 143; + int DEFAULT_ = 144; + int DEFAULTS = 145; + int DEFERRABLE = 146; + int DEFERRED = 147; + int DEFINE = 148; + int DEFINED = 149; + int DEFINER = 150; + int DEGREE = 151; + int DELETE = 152; + int DENSE_RANK = 153; + int DEPTH = 154; + int DEREF = 155; + int DERIVED = 156; + int DESC = 157; + int DESCRIBE = 158; + int DESCRIPTION = 159; + int DESCRIPTOR = 160; + int DETERMINISTIC = 161; + int DIAGNOSTICS = 162; + int DISALLOW = 163; + int DISCONNECT = 164; + int DISPATCH = 165; + int DISTINCT = 166; + int DOMAIN = 167; + int DOT_FORMAT = 168; + int DOUBLE = 169; + int DOW = 170; + int DOY = 171; + int DROP = 172; + int DYNAMIC = 173; + int DYNAMIC_FUNCTION = 174; + int DYNAMIC_FUNCTION_CODE = 175; + int EACH = 176; + int ELEMENT = 177; + int ELSE = 178; + int EMPTY = 179; + int ENCODING = 180; + int END = 181; + int END_EXEC = 182; + int END_FRAME = 183; + int END_PARTITION = 184; + int EPOCH = 185; + int EQUALS = 186; + int ERROR = 187; + int ESCAPE = 188; + int EVERY = 189; + int EXCEPT = 190; + int EXCEPTION = 191; + int EXCLUDE = 192; + int EXCLUDING = 193; + int EXEC = 194; + int EXECUTE = 195; + int EXISTS = 196; + int EXP = 197; + int EXPLAIN = 198; + int EXTEND = 199; + int EXTERNAL = 200; + int EXTRACT = 201; + int FALSE = 202; + int FETCH = 203; + int FILTER = 204; + int FINAL = 205; + int FIRST = 206; + int FIRST_VALUE = 207; + int FLOAT = 208; + int FLOOR = 209; + int FOLLOWING = 210; + int FOR = 211; + int FORMAT = 212; + int FOREIGN = 213; + int FORTRAN = 214; + int FOUND = 215; + int FRAC_SECOND = 216; + int FRAME_ROW = 217; + int FREE = 218; + int FROM = 219; + int FULL = 220; + int FUNCTION = 221; + int FUSION = 222; + int G = 223; + int GENERAL = 224; + int GENERATED = 225; + int GEOMETRY = 226; + int GET = 227; + int GLOBAL = 228; + int GO = 229; + int GOTO = 230; + int GRANT = 231; + int GRANTED = 232; + int GROUP = 233; + int GROUP_CONCAT = 234; + int GROUPING = 235; + int GROUPS = 236; + int HAVING = 237; + int HIERARCHY = 238; + int HOLD = 239; + int HOP = 240; + int HOUR = 241; + int HOURS = 242; + int IDENTITY = 243; + int IGNORE = 244; + int ILIKE = 245; + int IMMEDIATE = 246; + int IMMEDIATELY = 247; + int IMPLEMENTATION = 248; + int IMPORT = 249; + int IN = 250; + int INCLUDE = 251; + int INCLUDING = 252; + int INCREMENT = 253; + int INDICATOR = 254; + int INITIAL = 255; + int INITIALLY = 256; + int INNER = 257; + int INOUT = 258; + int INPUT = 259; + int INSENSITIVE = 260; + int INSERT = 261; + int INSTANCE = 262; + int INSTANTIABLE = 263; + int INT = 264; + int INTEGER = 265; + int INTERSECT = 266; + int INTERSECTION = 267; + int INTERVAL = 268; + int INTO = 269; + int INVOKER = 270; + int IS = 271; + int ISODOW = 272; + int ISOYEAR = 273; + int ISOLATION = 274; + int JAVA = 275; + int JOIN = 276; + int JSON = 277; + int JSON_ARRAY = 278; + int JSON_ARRAYAGG = 279; + int JSON_EXISTS = 280; + int JSON_OBJECT = 281; + int JSON_OBJECTAGG = 282; + int JSON_QUERY = 283; + int JSON_VALUE = 284; + int K = 285; + int KEY = 286; + int KEY_MEMBER = 287; + int KEY_TYPE = 288; + int LABEL = 289; + int LAG = 290; + int LANGUAGE = 291; + int LARGE = 292; + int LAST = 293; + int LAST_VALUE = 294; + int LATERAL = 295; + int LEAD = 296; + int LEADING = 297; + int LEFT = 298; + int LENGTH = 299; + int LEVEL = 300; + int LIBRARY = 301; + int LIKE = 302; + int LIKE_REGEX = 303; + int LIMIT = 304; + int LN = 305; + int LOCAL = 306; + int LOCALTIME = 307; + int LOCALTIMESTAMP = 308; + int LOCATOR = 309; + int LOWER = 310; + int M = 311; + int MAP = 312; + int MATCH = 313; + int MATCHED = 314; + int MATCHES = 315; + int MATCH_NUMBER = 316; + int MATCH_RECOGNIZE = 317; + int MAX = 318; + int MAXVALUE = 319; + int MEASURES = 320; + int MEMBER = 321; + int MERGE = 322; + int MESSAGE_LENGTH = 323; + int MESSAGE_OCTET_LENGTH = 324; + int MESSAGE_TEXT = 325; + int METHOD = 326; + int MICROSECOND = 327; + int MILLISECOND = 328; + int MILLENNIUM = 329; + int MIN = 330; + int MINUTE = 331; + int MINUTES = 332; + int MINVALUE = 333; + int MOD = 334; + int MODIFIES = 335; + int MODULE = 336; + int MONTH = 337; + int MONTHS = 338; + int MORE_ = 339; + int MULTISET = 340; + int MUMPS = 341; + int NAME = 342; + int NAMES = 343; + int NANOSECOND = 344; + int NATIONAL = 345; + int NATURAL = 346; + int NCHAR = 347; + int NCLOB = 348; + int NESTING = 349; + int NEW = 350; + int NEXT = 351; + int NO = 352; + int NONE = 353; + int NORMALIZE = 354; + int NORMALIZED = 355; + int NOT = 356; + int NTH_VALUE = 357; + int NTILE = 358; + int NULL = 359; + int NULLABLE = 360; + int NULLIF = 361; + int NULLS = 362; + int NUMBER = 363; + int NUMERIC = 364; + int OBJECT = 365; + int OCCURRENCES_REGEX = 366; + int OCTET_LENGTH = 367; + int OCTETS = 368; + int OF = 369; + int OFFSET = 370; + int OLD = 371; + int OMIT = 372; + int ON = 373; + int ONE = 374; + int ONLY = 375; + int OPEN = 376; + int OPTION = 377; + int OPTIONS = 378; + int OR = 379; + int ORDER = 380; + int ORDERING = 381; + int ORDINALITY = 382; + int OTHERS = 383; + int OUT = 384; + int OUTER = 385; + int OUTPUT = 386; + int OVER = 387; + int OVERLAPS = 388; + int OVERLAY = 389; + int OVERRIDING = 390; + int PAD = 391; + int PARAMETER = 392; + int PARAMETER_MODE = 393; + int PARAMETER_NAME = 394; + int PARAMETER_ORDINAL_POSITION = 395; + int PARAMETER_SPECIFIC_CATALOG = 396; + int PARAMETER_SPECIFIC_NAME = 397; + int PARAMETER_SPECIFIC_SCHEMA = 398; + int PARTIAL = 399; + int PARTITION = 400; + int PASCAL = 401; + int PASSING = 402; + int PASSTHROUGH = 403; + int PAST = 404; + int PATH = 405; + int PATTERN = 406; + int PER = 407; + int PERCENT = 408; + int PERCENTILE_CONT = 409; + int PERCENTILE_DISC = 410; + int PERCENT_RANK = 411; + int PERIOD = 412; + int PERMUTE = 413; + int PIVOT = 414; + int PLACING = 415; + int PLAN = 416; + int PLI = 417; + int PORTION = 418; + int POSITION = 419; + int POSITION_REGEX = 420; + int POWER = 421; + int PRECEDES = 422; + int PRECEDING = 423; + int PRECISION = 424; + int PREPARE = 425; + int PRESERVE = 426; + int PREV = 427; + int PRIMARY = 428; + int PRIOR = 429; + int PRIVILEGES = 430; + int PROCEDURE = 431; + int PUBLIC = 432; + int QUARTER = 433; + int RANGE = 434; + int RANK = 435; + int READ = 436; + int READS = 437; + int REAL = 438; + int RECURSIVE = 439; + int REF = 440; + int REFERENCES = 441; + int REFERENCING = 442; + int REGR_AVGX = 443; + int REGR_AVGY = 444; + int REGR_COUNT = 445; + int REGR_INTERCEPT = 446; + int REGR_R2 = 447; + int REGR_SLOPE = 448; + int REGR_SXX = 449; + int REGR_SXY = 450; + int REGR_SYY = 451; + int RELATIVE = 452; + int RELEASE = 453; + int REPEATABLE = 454; + int REPLACE = 455; + int RESET = 456; + int RESPECT = 457; + int RESTART = 458; + int RESTRICT = 459; + int RESULT = 460; + int RETURN = 461; + int RETURNED_CARDINALITY = 462; + int RETURNED_LENGTH = 463; + int RETURNED_OCTET_LENGTH = 464; + int RETURNED_SQLSTATE = 465; + int RETURNING = 466; + int RETURNS = 467; + int REVOKE = 468; + int RIGHT = 469; + int RLIKE = 470; + int ROLE = 471; + int ROLLBACK = 472; + int ROLLUP = 473; + int ROUTINE = 474; + int ROUTINE_CATALOG = 475; + int ROUTINE_NAME = 476; + int ROUTINE_SCHEMA = 477; + int ROW = 478; + int ROW_COUNT = 479; + int ROW_NUMBER = 480; + int ROWS = 481; + int RUNNING = 482; + int SAVEPOINT = 483; + int SCALAR = 484; + int SCALE = 485; + int SCHEMA = 486; + int SCHEMA_NAME = 487; + int SCOPE = 488; + int SCOPE_CATALOGS = 489; + int SCOPE_NAME = 490; + int SCOPE_SCHEMA = 491; + int SCROLL = 492; + int SEARCH = 493; + int SECOND = 494; + int SECONDS = 495; + int SECTION = 496; + int SECURITY = 497; + int SEEK = 498; + int SELECT = 499; + int SELF = 500; + int SENSITIVE = 501; + int SEPARATOR = 502; + int SEQUENCE = 503; + int SERIALIZABLE = 504; + int SERVER = 505; + int SERVER_NAME = 506; + int SESSION = 507; + int SESSION_USER = 508; + int SET = 509; + int SETS = 510; + int SET_MINUS = 511; + int SHOW = 512; + int SIMILAR = 513; + int SIMPLE = 514; + int SIZE = 515; + int SKIP_ = 516; + int SMALLINT = 517; + int SOME = 518; + int SOURCE = 519; + int SPACE = 520; + int SPECIFIC = 521; + int SPECIFIC_NAME = 522; + int SPECIFICTYPE = 523; + int SQL = 524; + int SQLEXCEPTION = 525; + int SQLSTATE = 526; + int SQLWARNING = 527; + int SQL_BIGINT = 528; + int SQL_BINARY = 529; + int SQL_BIT = 530; + int SQL_BLOB = 531; + int SQL_BOOLEAN = 532; + int SQL_CHAR = 533; + int SQL_CLOB = 534; + int SQL_DATE = 535; + int SQL_DECIMAL = 536; + int SQL_DOUBLE = 537; + int SQL_FLOAT = 538; + int SQL_INTEGER = 539; + int SQL_INTERVAL_DAY = 540; + int SQL_INTERVAL_DAY_TO_HOUR = 541; + int SQL_INTERVAL_DAY_TO_MINUTE = 542; + int SQL_INTERVAL_DAY_TO_SECOND = 543; + int SQL_INTERVAL_HOUR = 544; + int SQL_INTERVAL_HOUR_TO_MINUTE = 545; + int SQL_INTERVAL_HOUR_TO_SECOND = 546; + int SQL_INTERVAL_MINUTE = 547; + int SQL_INTERVAL_MINUTE_TO_SECOND = 548; + int SQL_INTERVAL_MONTH = 549; + int SQL_INTERVAL_SECOND = 550; + int SQL_INTERVAL_YEAR = 551; + int SQL_INTERVAL_YEAR_TO_MONTH = 552; + int SQL_LONGVARBINARY = 553; + int SQL_LONGVARCHAR = 554; + int SQL_LONGVARNCHAR = 555; + int SQL_NCHAR = 556; + int SQL_NCLOB = 557; + int SQL_NUMERIC = 558; + int SQL_NVARCHAR = 559; + int SQL_REAL = 560; + int SQL_SMALLINT = 561; + int SQL_TIME = 562; + int SQL_TIMESTAMP = 563; + int SQL_TINYINT = 564; + int SQL_TSI_DAY = 565; + int SQL_TSI_FRAC_SECOND = 566; + int SQL_TSI_HOUR = 567; + int SQL_TSI_MICROSECOND = 568; + int SQL_TSI_MINUTE = 569; + int SQL_TSI_MONTH = 570; + int SQL_TSI_QUARTER = 571; + int SQL_TSI_SECOND = 572; + int SQL_TSI_WEEK = 573; + int SQL_TSI_YEAR = 574; + int SQL_VARBINARY = 575; + int SQL_VARCHAR = 576; + int SQRT = 577; + int START = 578; + int STATE = 579; + int STATEMENT = 580; + int STATIC = 581; + int STDDEV_POP = 582; + int STDDEV_SAMP = 583; + int STREAM = 584; + int STRING_AGG = 585; + int STRUCTURE = 586; + int STYLE = 587; + int SUBCLASS_ORIGIN = 588; + int SUBMULTISET = 589; + int SUBSET = 590; + int SUBSTITUTE = 591; + int SUBSTRING = 592; + int SUBSTRING_REGEX = 593; + int SUCCEEDS = 594; + int SUM = 595; + int SYMMETRIC = 596; + int SYSTEM = 597; + int SYSTEM_TIME = 598; + int SYSTEM_USER = 599; + int TABLE = 600; + int TABLE_NAME = 601; + int TABLESAMPLE = 602; + int TEMPORARY = 603; + int THEN = 604; + int TIES = 605; + int TIME = 606; + int TIMESTAMP = 607; + int TIMESTAMPADD = 608; + int TIMESTAMPDIFF = 609; + int TIMEZONE_HOUR = 610; + int TIMEZONE_MINUTE = 611; + int TINYINT = 612; + int TO = 613; + int TOP_LEVEL_COUNT = 614; + int TRAILING = 615; + int TRANSACTION = 616; + int TRANSACTIONS_ACTIVE = 617; + int TRANSACTIONS_COMMITTED = 618; + int TRANSACTIONS_ROLLED_BACK = 619; + int TRANSFORM = 620; + int TRANSFORMS = 621; + int TRANSLATE = 622; + int TRANSLATE_REGEX = 623; + int TRANSLATION = 624; + int TREAT = 625; + int TRIGGER = 626; + int TRIGGER_CATALOG = 627; + int TRIGGER_NAME = 628; + int TRIGGER_SCHEMA = 629; + int TRIM = 630; + int TRIM_ARRAY = 631; + int TRUE = 632; + int TRUNCATE = 633; + int TUMBLE = 634; + int TYPE = 635; + int UESCAPE = 636; + int UNBOUNDED = 637; + int UNCOMMITTED = 638; + int UNCONDITIONAL = 639; + int UNDER = 640; + int UNION = 641; + int UNIQUE = 642; + int UNKNOWN = 643; + int UNPIVOT = 644; + int UNNAMED = 645; + int UNNEST = 646; + int UPDATE = 647; + int UPPER = 648; + int UPSERT = 649; + int USAGE = 650; + int USER = 651; + int USER_DEFINED_TYPE_CATALOG = 652; + int USER_DEFINED_TYPE_CODE = 653; + int USER_DEFINED_TYPE_NAME = 654; + int USER_DEFINED_TYPE_SCHEMA = 655; + int USING = 656; + int UTF8 = 657; + int UTF16 = 658; + int UTF32 = 659; + int VALUE = 660; + int VALUES = 661; + int VALUE_OF = 662; + int VAR_POP = 663; + int VAR_SAMP = 664; + int VARBINARY = 665; + int VARCHAR = 666; + int VARYING = 667; + int VERSION = 668; + int VERSIONING = 669; + int VIEW = 670; + int WEEK = 671; + int WHEN = 672; + int WHENEVER = 673; + int WHERE = 674; + int WIDTH_BUCKET = 675; + int WINDOW = 676; + int WITH = 677; + int WITHIN = 678; + int WITHOUT = 679; + int WORK = 680; + int WRAPPER = 681; + int WRITE = 682; + int XML = 683; + int YEAR = 684; + int YEARS = 685; + int ZONE = 686; + int SEMI = 687; + int IF = 688; + int TEMPLATE = 689; + int BACKUPS = 690; + int AFFINITY_KEY = 691; + int ATOMICITY = 692; + int WRITE_SYNCHRONIZATION_MODE = 693; + int CACHE_GROUP = 694; + int CACHE_NAME = 695; + int DATA_REGION = 696; + int VALUE_TYPE = 697; + int ENCRYPTED = 698; + int INDEX = 699; + int PARALLEL = 700; + int INLINE_SIZE = 701; + int LOGGING = 702; + int NOLOGGING = 703; + int PASSWORD = 704; + int KILL = 705; + int SCAN = 706; + int CONTINUOUS = 707; + int SERVICE = 708; + int COMPUTE = 709; + int ASYNC = 710; + int QUERY = 711; + int UUID = 712; + int UNSIGNED_INTEGER_LITERAL = 713; + int APPROX_NUMERIC_LITERAL = 714; + int DECIMAL_NUMERIC_LITERAL = 715; + int EXPONENT = 716; + int HEXDIGIT = 717; + int WHITESPACE = 718; + int BINARY_STRING_LITERAL = 719; + int QUOTED_STRING = 720; + int PREFIXED_STRING_LITERAL = 721; + int UNICODE_STRING_LITERAL = 722; + int CHARSETNAME = 723; + int BIG_QUERY_DOUBLE_QUOTED_STRING = 724; + int BIG_QUERY_QUOTED_STRING = 725; + int UNICODE_QUOTED_ESCAPE_CHAR = 726; + int LPAREN = 727; + int RPAREN = 728; + int LBRACE_D = 729; + int LBRACE_T = 730; + int LBRACE_TS = 731; + int LBRACE_FN = 732; + int LBRACE = 733; + int RBRACE = 734; + int LBRACKET = 735; + int RBRACKET = 736; + int SEMICOLON = 737; + int DOT = 738; + int COMMA = 739; + int EQ = 740; + int GT = 741; + int LT = 742; + int HOOK = 743; + int COLON = 744; + int LE = 745; + int GE = 746; + int NE = 747; + int NE2 = 748; + int PLUS = 749; + int MINUS = 750; + int STAR = 751; + int SLASH = 752; + int PERCENT_REMAINDER = 753; + int CONCAT = 754; + int NAMED_ARGUMENT_ASSIGNMENT = 755; + int DOUBLE_PERIOD = 756; + int QUOTE = 757; + int DOUBLE_QUOTE = 758; + int VERTICAL_BAR = 759; + int CARET = 760; + int DOLLAR = 761; + int INFIX_CAST = 762; + int HINT_BEG = 768; + int COMMENT_END = 769; + int SINGLE_LINE_COMMENT = 772; + int FORMAL_COMMENT = 773; + int MULTI_LINE_COMMENT = 774; + int BRACKET_QUOTED_IDENTIFIER = 776; + int QUOTED_IDENTIFIER = 777; + int BACK_QUOTED_IDENTIFIER = 778; + int BIG_QUERY_BACK_QUOTED_IDENTIFIER = 779; + int HYPHENATED_IDENTIFIER = 780; + int IDENTIFIER = 781; + int COLLATION_ID = 782; + int UNICODE_QUOTED_IDENTIFIER = 783; + int LETTER = 784; + int DIGIT = 785; + int BEL = 786; + + int DEFAULT = 0; + int DQID = 1; + int BTID = 2; + int BQID = 3; + int BQHID = 4; + int IN_FORMAL_COMMENT = 5; + int IN_MULTI_LINE_COMMENT = 6; + + String[] tokenImage = { + "", + "\"!\"", + "\"~\"", + "\"A\"", + "\"ABS\"", + "\"ABSENT\"", + "\"ABSOLUTE\"", + "\"ACTION\"", + "\"ADA\"", + "\"ADD\"", + "\"ADMIN\"", + "\"AFTER\"", + "\"ALL\"", + "\"ALLOCATE\"", + "\"ALLOW\"", + "\"ALTER\"", + "\"ALWAYS\"", + "\"AND\"", + "\"ANY\"", + "\"APPLY\"", + "\"ARE\"", + "\"ARRAY\"", + "\"ARRAY_AGG\"", + "\"ARRAY_CONCAT_AGG\"", + "\"ARRAY_MAX_CARDINALITY\"", + "\"AS\"", + "\"ASC\"", + "\"ASENSITIVE\"", + "\"ASSERTION\"", + "\"ASSIGNMENT\"", + "\"ASYMMETRIC\"", + "\"AT\"", + "\"ATOMIC\"", + "\"ATTRIBUTE\"", + "\"ATTRIBUTES\"", + "\"AUTHORIZATION\"", + "\"AVG\"", + "\"BEFORE\"", + "\"BEGIN\"", + "\"BEGIN_FRAME\"", + "\"BEGIN_PARTITION\"", + "\"BERNOULLI\"", + "\"BETWEEN\"", + "\"BIGINT\"", + "\"BINARY\"", + "\"BIT\"", + "\"BLOB\"", + "\"BOOLEAN\"", + "\"BOTH\"", + "\"BREADTH\"", + "\"BY\"", + "\"C\"", + "\"CALL\"", + "\"CALLED\"", + "\"CARDINALITY\"", + "\"CASCADE\"", + "\"CASCADED\"", + "\"CASE\"", + "\"CAST\"", + "\"CATALOG\"", + "\"CATALOG_NAME\"", + "\"CEIL\"", + "\"CEILING\"", + "\"CENTURY\"", + "\"CHAIN\"", + "\"CHAR\"", + "\"CHAR_LENGTH\"", + "\"CHARACTER\"", + "\"CHARACTER_LENGTH\"", + "\"CHARACTER_SET_CATALOG\"", + "\"CHARACTER_SET_NAME\"", + "\"CHARACTER_SET_SCHEMA\"", + "\"CHARACTERISTICS\"", + "\"CHARACTERS\"", + "\"CHECK\"", + "\"CLASSIFIER\"", + "\"CLASS_ORIGIN\"", + "\"CLOB\"", + "\"CLOSE\"", + "\"COALESCE\"", + "\"COBOL\"", + "\"COLLATE\"", + "\"COLLATION\"", + "\"COLLATION_CATALOG\"", + "\"COLLATION_NAME\"", + "\"COLLATION_SCHEMA\"", + "\"COLLECT\"", + "\"COLUMN\"", + "\"COLUMN_NAME\"", + "\"COMMAND_FUNCTION\"", + "\"COMMAND_FUNCTION_CODE\"", + "\"COMMIT\"", + "\"COMMITTED\"", + "\"CONDITION\"", + "\"CONDITIONAL\"", + "\"CONDITION_NUMBER\"", + "\"CONNECT\"", + "\"CONNECTION\"", + "\"CONNECTION_NAME\"", + "\"CONSTRAINT\"", + "\"CONSTRAINT_CATALOG\"", + "\"CONSTRAINT_NAME\"", + "\"CONSTRAINT_SCHEMA\"", + "\"CONSTRAINTS\"", + "\"CONSTRUCTOR\"", + "\"CONTAINS\"", + "\"CONTINUE\"", + "\"CONVERT\"", + "\"CORR\"", + "\"CORRESPONDING\"", + "\"COUNT\"", + "\"COVAR_POP\"", + "\"COVAR_SAMP\"", + "\"CREATE\"", + "\"CROSS\"", + "\"CUBE\"", + "\"CUME_DIST\"", + "\"CURRENT\"", + "\"CURRENT_CATALOG\"", + "\"CURRENT_DATE\"", + "\"CURRENT_DEFAULT_TRANSFORM_GROUP\"", + "\"CURRENT_PATH\"", + "\"CURRENT_ROLE\"", + "\"CURRENT_ROW\"", + "\"CURRENT_SCHEMA\"", + "\"CURRENT_TIME\"", + "\"CURRENT_TIMESTAMP\"", + "\"CURRENT_TRANSFORM_GROUP_FOR_TYPE\"", + "\"CURRENT_USER\"", + "\"CURSOR\"", + "\"CURSOR_NAME\"", + "\"CYCLE\"", + "\"DATA\"", + "\"DATABASE\"", + "\"DATE\"", + "\"DATETIME_INTERVAL_CODE\"", + "\"DATETIME_INTERVAL_PRECISION\"", + "\"DAY\"", + "\"DAYS\"", + "\"DEALLOCATE\"", + "\"DEC\"", + "\"DECADE\"", + "\"DECIMAL\"", + "\"DECLARE\"", + "\"DEFAULT\"", + "\"DEFAULTS\"", + "\"DEFERRABLE\"", + "\"DEFERRED\"", + "\"DEFINE\"", + "\"DEFINED\"", + "\"DEFINER\"", + "\"DEGREE\"", + "\"DELETE\"", + "\"DENSE_RANK\"", + "\"DEPTH\"", + "\"DEREF\"", + "\"DERIVED\"", + "\"DESC\"", + "\"DESCRIBE\"", + "\"DESCRIPTION\"", + "\"DESCRIPTOR\"", + "\"DETERMINISTIC\"", + "\"DIAGNOSTICS\"", + "\"DISALLOW\"", + "\"DISCONNECT\"", + "\"DISPATCH\"", + "\"DISTINCT\"", + "\"DOMAIN\"", + "\"DOT\"", + "\"DOUBLE\"", + "\"DOW\"", + "\"DOY\"", + "\"DROP\"", + "\"DYNAMIC\"", + "\"DYNAMIC_FUNCTION\"", + "\"DYNAMIC_FUNCTION_CODE\"", + "\"EACH\"", + "\"ELEMENT\"", + "\"ELSE\"", + "\"EMPTY\"", + "\"ENCODING\"", + "\"END\"", + "\"END-EXEC\"", + "\"END_FRAME\"", + "\"END_PARTITION\"", + "\"EPOCH\"", + "\"EQUALS\"", + "\"ERROR\"", + "\"ESCAPE\"", + "\"EVERY\"", + "\"EXCEPT\"", + "\"EXCEPTION\"", + "\"EXCLUDE\"", + "\"EXCLUDING\"", + "\"EXEC\"", + "\"EXECUTE\"", + "\"EXISTS\"", + "\"EXP\"", + "\"EXPLAIN\"", + "\"EXTEND\"", + "\"EXTERNAL\"", + "\"EXTRACT\"", + "\"FALSE\"", + "\"FETCH\"", + "\"FILTER\"", + "\"FINAL\"", + "\"FIRST\"", + "\"FIRST_VALUE\"", + "\"FLOAT\"", + "\"FLOOR\"", + "\"FOLLOWING\"", + "\"FOR\"", + "\"FORMAT\"", + "\"FOREIGN\"", + "\"FORTRAN\"", + "\"FOUND\"", + "\"FRAC_SECOND\"", + "\"FRAME_ROW\"", + "\"FREE\"", + "\"FROM\"", + "\"FULL\"", + "\"FUNCTION\"", + "\"FUSION\"", + "\"G\"", + "\"GENERAL\"", + "\"GENERATED\"", + "\"GEOMETRY\"", + "\"GET\"", + "\"GLOBAL\"", + "\"GO\"", + "\"GOTO\"", + "\"GRANT\"", + "\"GRANTED\"", + "\"GROUP\"", + "\"GROUP_CONCAT\"", + "\"GROUPING\"", + "\"GROUPS\"", + "\"HAVING\"", + "\"HIERARCHY\"", + "\"HOLD\"", + "\"HOP\"", + "\"HOUR\"", + "\"HOURS\"", + "\"IDENTITY\"", + "\"IGNORE\"", + "\"ILIKE\"", + "\"IMMEDIATE\"", + "\"IMMEDIATELY\"", + "\"IMPLEMENTATION\"", + "\"IMPORT\"", + "\"IN\"", + "\"INCLUDE\"", + "\"INCLUDING\"", + "\"INCREMENT\"", + "\"INDICATOR\"", + "\"INITIAL\"", + "\"INITIALLY\"", + "\"INNER\"", + "\"INOUT\"", + "\"INPUT\"", + "\"INSENSITIVE\"", + "\"INSERT\"", + "\"INSTANCE\"", + "\"INSTANTIABLE\"", + "\"INT\"", + "\"INTEGER\"", + "\"INTERSECT\"", + "\"INTERSECTION\"", + "\"INTERVAL\"", + "\"INTO\"", + "\"INVOKER\"", + "\"IS\"", + "\"ISODOW\"", + "\"ISOYEAR\"", + "\"ISOLATION\"", + "\"JAVA\"", + "\"JOIN\"", + "\"JSON\"", + "\"JSON_ARRAY\"", + "\"JSON_ARRAYAGG\"", + "\"JSON_EXISTS\"", + "\"JSON_OBJECT\"", + "\"JSON_OBJECTAGG\"", + "\"JSON_QUERY\"", + "\"JSON_VALUE\"", + "\"K\"", + "\"KEY\"", + "\"KEY_MEMBER\"", + "\"KEY_TYPE\"", + "\"LABEL\"", + "\"LAG\"", + "\"LANGUAGE\"", + "\"LARGE\"", + "\"LAST\"", + "\"LAST_VALUE\"", + "\"LATERAL\"", + "\"LEAD\"", + "\"LEADING\"", + "\"LEFT\"", + "\"LENGTH\"", + "\"LEVEL\"", + "\"LIBRARY\"", + "\"LIKE\"", + "\"LIKE_REGEX\"", + "\"LIMIT\"", + "\"LN\"", + "\"LOCAL\"", + "\"LOCALTIME\"", + "\"LOCALTIMESTAMP\"", + "\"LOCATOR\"", + "\"LOWER\"", + "\"M\"", + "\"MAP\"", + "\"MATCH\"", + "\"MATCHED\"", + "\"MATCHES\"", + "\"MATCH_NUMBER\"", + "\"MATCH_RECOGNIZE\"", + "\"MAX\"", + "\"MAXVALUE\"", + "\"MEASURES\"", + "\"MEMBER\"", + "\"MERGE\"", + "\"MESSAGE_LENGTH\"", + "\"MESSAGE_OCTET_LENGTH\"", + "\"MESSAGE_TEXT\"", + "\"METHOD\"", + "\"MICROSECOND\"", + "\"MILLISECOND\"", + "\"MILLENNIUM\"", + "\"MIN\"", + "\"MINUTE\"", + "\"MINUTES\"", + "\"MINVALUE\"", + "\"MOD\"", + "\"MODIFIES\"", + "\"MODULE\"", + "\"MONTH\"", + "\"MONTHS\"", + "\"MORE\"", + "\"MULTISET\"", + "\"MUMPS\"", + "\"NAME\"", + "\"NAMES\"", + "\"NANOSECOND\"", + "\"NATIONAL\"", + "\"NATURAL\"", + "\"NCHAR\"", + "\"NCLOB\"", + "\"NESTING\"", + "\"NEW\"", + "\"NEXT\"", + "\"NO\"", + "\"NONE\"", + "\"NORMALIZE\"", + "\"NORMALIZED\"", + "\"NOT\"", + "\"NTH_VALUE\"", + "\"NTILE\"", + "\"NULL\"", + "\"NULLABLE\"", + "\"NULLIF\"", + "\"NULLS\"", + "\"NUMBER\"", + "\"NUMERIC\"", + "\"OBJECT\"", + "\"OCCURRENCES_REGEX\"", + "\"OCTET_LENGTH\"", + "\"OCTETS\"", + "\"OF\"", + "\"OFFSET\"", + "\"OLD\"", + "\"OMIT\"", + "\"ON\"", + "\"ONE\"", + "\"ONLY\"", + "\"OPEN\"", + "\"OPTION\"", + "\"OPTIONS\"", + "\"OR\"", + "\"ORDER\"", + "\"ORDERING\"", + "\"ORDINALITY\"", + "\"OTHERS\"", + "\"OUT\"", + "\"OUTER\"", + "\"OUTPUT\"", + "\"OVER\"", + "\"OVERLAPS\"", + "\"OVERLAY\"", + "\"OVERRIDING\"", + "\"PAD\"", + "\"PARAMETER\"", + "\"PARAMETER_MODE\"", + "\"PARAMETER_NAME\"", + "\"PARAMETER_ORDINAL_POSITION\"", + "\"PARAMETER_SPECIFIC_CATALOG\"", + "\"PARAMETER_SPECIFIC_NAME\"", + "\"PARAMETER_SPECIFIC_SCHEMA\"", + "\"PARTIAL\"", + "\"PARTITION\"", + "\"PASCAL\"", + "\"PASSING\"", + "\"PASSTHROUGH\"", + "\"PAST\"", + "\"PATH\"", + "\"PATTERN\"", + "\"PER\"", + "\"PERCENT\"", + "\"PERCENTILE_CONT\"", + "\"PERCENTILE_DISC\"", + "\"PERCENT_RANK\"", + "\"PERIOD\"", + "\"PERMUTE\"", + "\"PIVOT\"", + "\"PLACING\"", + "\"PLAN\"", + "\"PLI\"", + "\"PORTION\"", + "\"POSITION\"", + "\"POSITION_REGEX\"", + "\"POWER\"", + "\"PRECEDES\"", + "\"PRECEDING\"", + "\"PRECISION\"", + "\"PREPARE\"", + "\"PRESERVE\"", + "\"PREV\"", + "\"PRIMARY\"", + "\"PRIOR\"", + "\"PRIVILEGES\"", + "\"PROCEDURE\"", + "\"PUBLIC\"", + "\"QUARTER\"", + "\"RANGE\"", + "\"RANK\"", + "\"READ\"", + "\"READS\"", + "\"REAL\"", + "\"RECURSIVE\"", + "\"REF\"", + "\"REFERENCES\"", + "\"REFERENCING\"", + "\"REGR_AVGX\"", + "\"REGR_AVGY\"", + "\"REGR_COUNT\"", + "\"REGR_INTERCEPT\"", + "\"REGR_R2\"", + "\"REGR_SLOPE\"", + "\"REGR_SXX\"", + "\"REGR_SXY\"", + "\"REGR_SYY\"", + "\"RELATIVE\"", + "\"RELEASE\"", + "\"REPEATABLE\"", + "\"REPLACE\"", + "\"RESET\"", + "\"RESPECT\"", + "\"RESTART\"", + "\"RESTRICT\"", + "\"RESULT\"", + "\"RETURN\"", + "\"RETURNED_CARDINALITY\"", + "\"RETURNED_LENGTH\"", + "\"RETURNED_OCTET_LENGTH\"", + "\"RETURNED_SQLSTATE\"", + "\"RETURNING\"", + "\"RETURNS\"", + "\"REVOKE\"", + "\"RIGHT\"", + "\"RLIKE\"", + "\"ROLE\"", + "\"ROLLBACK\"", + "\"ROLLUP\"", + "\"ROUTINE\"", + "\"ROUTINE_CATALOG\"", + "\"ROUTINE_NAME\"", + "\"ROUTINE_SCHEMA\"", + "\"ROW\"", + "\"ROW_COUNT\"", + "\"ROW_NUMBER\"", + "\"ROWS\"", + "\"RUNNING\"", + "\"SAVEPOINT\"", + "\"SCALAR\"", + "\"SCALE\"", + "\"SCHEMA\"", + "\"SCHEMA_NAME\"", + "\"SCOPE\"", + "\"SCOPE_CATALOGS\"", + "\"SCOPE_NAME\"", + "\"SCOPE_SCHEMA\"", + "\"SCROLL\"", + "\"SEARCH\"", + "\"SECOND\"", + "\"SECONDS\"", + "\"SECTION\"", + "\"SECURITY\"", + "\"SEEK\"", + "\"SELECT\"", + "\"SELF\"", + "\"SENSITIVE\"", + "\"SEPARATOR\"", + "\"SEQUENCE\"", + "\"SERIALIZABLE\"", + "\"SERVER\"", + "\"SERVER_NAME\"", + "\"SESSION\"", + "\"SESSION_USER\"", + "\"SET\"", + "\"SETS\"", + "\"MINUS\"", + "\"SHOW\"", + "\"SIMILAR\"", + "\"SIMPLE\"", + "\"SIZE\"", + "\"SKIP\"", + "\"SMALLINT\"", + "\"SOME\"", + "\"SOURCE\"", + "\"SPACE\"", + "\"SPECIFIC\"", + "\"SPECIFIC_NAME\"", + "\"SPECIFICTYPE\"", + "\"SQL\"", + "\"SQLEXCEPTION\"", + "\"SQLSTATE\"", + "\"SQLWARNING\"", + "\"SQL_BIGINT\"", + "\"SQL_BINARY\"", + "\"SQL_BIT\"", + "\"SQL_BLOB\"", + "\"SQL_BOOLEAN\"", + "\"SQL_CHAR\"", + "\"SQL_CLOB\"", + "\"SQL_DATE\"", + "\"SQL_DECIMAL\"", + "\"SQL_DOUBLE\"", + "\"SQL_FLOAT\"", + "\"SQL_INTEGER\"", + "\"SQL_INTERVAL_DAY\"", + "\"SQL_INTERVAL_DAY_TO_HOUR\"", + "\"SQL_INTERVAL_DAY_TO_MINUTE\"", + "\"SQL_INTERVAL_DAY_TO_SECOND\"", + "\"SQL_INTERVAL_HOUR\"", + "\"SQL_INTERVAL_HOUR_TO_MINUTE\"", + "\"SQL_INTERVAL_HOUR_TO_SECOND\"", + "\"SQL_INTERVAL_MINUTE\"", + "\"SQL_INTERVAL_MINUTE_TO_SECOND\"", + "\"SQL_INTERVAL_MONTH\"", + "\"SQL_INTERVAL_SECOND\"", + "\"SQL_INTERVAL_YEAR\"", + "\"SQL_INTERVAL_YEAR_TO_MONTH\"", + "\"SQL_LONGVARBINARY\"", + "\"SQL_LONGVARCHAR\"", + "\"SQL_LONGVARNCHAR\"", + "\"SQL_NCHAR\"", + "\"SQL_NCLOB\"", + "\"SQL_NUMERIC\"", + "\"SQL_NVARCHAR\"", + "\"SQL_REAL\"", + "\"SQL_SMALLINT\"", + "\"SQL_TIME\"", + "\"SQL_TIMESTAMP\"", + "\"SQL_TINYINT\"", + "\"SQL_TSI_DAY\"", + "\"SQL_TSI_FRAC_SECOND\"", + "\"SQL_TSI_HOUR\"", + "\"SQL_TSI_MICROSECOND\"", + "\"SQL_TSI_MINUTE\"", + "\"SQL_TSI_MONTH\"", + "\"SQL_TSI_QUARTER\"", + "\"SQL_TSI_SECOND\"", + "\"SQL_TSI_WEEK\"", + "\"SQL_TSI_YEAR\"", + "\"SQL_VARBINARY\"", + "\"SQL_VARCHAR\"", + "\"SQRT\"", + "\"START\"", + "\"STATE\"", + "\"STATEMENT\"", + "\"STATIC\"", + "\"STDDEV_POP\"", + "\"STDDEV_SAMP\"", + "\"STREAM\"", + "\"STRING_AGG\"", + "\"STRUCTURE\"", + "\"STYLE\"", + "\"SUBCLASS_ORIGIN\"", + "\"SUBMULTISET\"", + "\"SUBSET\"", + "\"SUBSTITUTE\"", + "\"SUBSTRING\"", + "\"SUBSTRING_REGEX\"", + "\"SUCCEEDS\"", + "\"SUM\"", + "\"SYMMETRIC\"", + "\"SYSTEM\"", + "\"SYSTEM_TIME\"", + "\"SYSTEM_USER\"", + "\"TABLE\"", + "\"TABLE_NAME\"", + "\"TABLESAMPLE\"", + "\"TEMPORARY\"", + "\"THEN\"", + "\"TIES\"", + "\"TIME\"", + "\"TIMESTAMP\"", + "\"TIMESTAMPADD\"", + "\"TIMESTAMPDIFF\"", + "\"TIMEZONE_HOUR\"", + "\"TIMEZONE_MINUTE\"", + "\"TINYINT\"", + "\"TO\"", + "\"TOP_LEVEL_COUNT\"", + "\"TRAILING\"", + "\"TRANSACTION\"", + "\"TRANSACTIONS_ACTIVE\"", + "\"TRANSACTIONS_COMMITTED\"", + "\"TRANSACTIONS_ROLLED_BACK\"", + "\"TRANSFORM\"", + "\"TRANSFORMS\"", + "\"TRANSLATE\"", + "\"TRANSLATE_REGEX\"", + "\"TRANSLATION\"", + "\"TREAT\"", + "\"TRIGGER\"", + "\"TRIGGER_CATALOG\"", + "\"TRIGGER_NAME\"", + "\"TRIGGER_SCHEMA\"", + "\"TRIM\"", + "\"TRIM_ARRAY\"", + "\"TRUE\"", + "\"TRUNCATE\"", + "\"TUMBLE\"", + "\"TYPE\"", + "\"UESCAPE\"", + "\"UNBOUNDED\"", + "\"UNCOMMITTED\"", + "\"UNCONDITIONAL\"", + "\"UNDER\"", + "\"UNION\"", + "\"UNIQUE\"", + "\"UNKNOWN\"", + "\"UNPIVOT\"", + "\"UNNAMED\"", + "\"UNNEST\"", + "\"UPDATE\"", + "\"UPPER\"", + "\"UPSERT\"", + "\"USAGE\"", + "\"USER\"", + "\"USER_DEFINED_TYPE_CATALOG\"", + "\"USER_DEFINED_TYPE_CODE\"", + "\"USER_DEFINED_TYPE_NAME\"", + "\"USER_DEFINED_TYPE_SCHEMA\"", + "\"USING\"", + "\"UTF8\"", + "\"UTF16\"", + "\"UTF32\"", + "\"VALUE\"", + "\"VALUES\"", + "\"VALUE_OF\"", + "\"VAR_POP\"", + "\"VAR_SAMP\"", + "\"VARBINARY\"", + "\"VARCHAR\"", + "\"VARYING\"", + "\"VERSION\"", + "\"VERSIONING\"", + "\"VIEW\"", + "\"WEEK\"", + "\"WHEN\"", + "\"WHENEVER\"", + "\"WHERE\"", + "\"WIDTH_BUCKET\"", + "\"WINDOW\"", + "\"WITH\"", + "\"WITHIN\"", + "\"WITHOUT\"", + "\"WORK\"", + "\"WRAPPER\"", + "\"WRITE\"", + "\"XML\"", + "\"YEAR\"", + "\"YEARS\"", + "\"ZONE\"", + "\"SEMI\"", + "\"IF\"", + "\"TEMPLATE\"", + "\"BACKUPS\"", + "\"AFFINITY_KEY\"", + "\"ATOMICITY\"", + "\"WRITE_SYNCHRONIZATION_MODE\"", + "\"CACHE_GROUP\"", + "\"CACHE_NAME\"", + "\"DATA_REGION\"", + "\"VALUE_TYPE\"", + "\"ENCRYPTED\"", + "\"INDEX\"", + "\"PARALLEL\"", + "\"INLINE_SIZE\"", + "\"LOGGING\"", + "\"NOLOGGING\"", + "\"PASSWORD\"", + "\"KILL\"", + "\"SCAN\"", + "\"CONTINUOUS\"", + "\"SERVICE\"", + "\"COMPUTE\"", + "\"ASYNC\"", + "\"QUERY\"", + "\"UUID\"", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\"(\"", + "\")\"", + "", + "", + "", + "", + "\"{\"", + "\"}\"", + "\"[\"", + "\"]\"", + "\";\"", + "\".\"", + "\",\"", + "\"=\"", + "\">\"", + "\"<\"", + "\"?\"", + "\":\"", + "\"<=\"", + "\">=\"", + "\"<>\"", + "\"!=\"", + "\"+\"", + "\"-\"", + "\"*\"", + "\"/\"", + "\"%\"", + "\"||\"", + "\"=>\"", + "\"..\"", + "\"\\\'\"", + "\"\\\"\"", + "\"|\"", + "\"^\"", + "\"$\"", + "\"::\"", + "\" \"", + "\"\\t\"", + "\"\\n\"", + "\"\\r\"", + "\"\\f\"", + "\"/*+\"", + "\"*/\"", + "", + "\"/*\"", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + }; + +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplTokenManager.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplTokenManager.java new file mode 100644 index 0000000000000..4770f9e18a84f --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplTokenManager.java @@ -0,0 +1,26455 @@ +/* Generated By:JavaCC: Do not edit this line. IgniteSqlParserImplTokenManager.java */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; +import java.util.UUID; +import org.apache.calcite.sql.SqlCreate; +import org.apache.calcite.sql.SqlDrop; +import org.apache.calcite.sql.SqlLiteral; +import org.apache.calcite.schema.ColumnStrategy; +import org.apache.ignite.internal.processors.query.calcite.util.IgniteResource; +import org.apache.ignite.lang.IgniteUuid; +import org.apache.calcite.sql.ddl.SqlDdlNodes; +import org.apache.ignite.internal.processors.query.calcite.sql.*; +import org.apache.calcite.avatica.util.Casing; +import org.apache.calcite.avatica.util.DateTimeUtils; +import org.apache.calcite.avatica.util.TimeUnit; +import org.apache.calcite.rel.type.RelDataType; +import org.apache.calcite.runtime.CalciteContextException; +import org.apache.calcite.sql.JoinConditionType; +import org.apache.calcite.sql.JoinType; +import org.apache.calcite.sql.SqlAlter; +import org.apache.calcite.sql.SqlBasicTypeNameSpec; +import org.apache.calcite.sql.SqlBinaryOperator; +import org.apache.calcite.sql.SqlCall; +import org.apache.calcite.sql.SqlCharStringLiteral; +import org.apache.calcite.sql.SqlCollation; +import org.apache.calcite.sql.SqlCollectionTypeNameSpec; +import org.apache.calcite.sql.SqlDataTypeSpec; +import org.apache.calcite.sql.SqlDateLiteral; +import org.apache.calcite.sql.SqlDelete; +import org.apache.calcite.sql.SqlDescribeSchema; +import org.apache.calcite.sql.SqlDescribeTable; +import org.apache.calcite.sql.SqlDynamicParam; +import org.apache.calcite.sql.SqlExplain; +import org.apache.calcite.sql.SqlExplainFormat; +import org.apache.calcite.sql.SqlExplainLevel; +import org.apache.calcite.sql.SqlFunction; +import org.apache.calcite.sql.SqlFunctionCategory; +import org.apache.calcite.sql.SqlHint; +import org.apache.calcite.sql.SqlIdentifier; +import org.apache.calcite.sql.SqlInsert; +import org.apache.calcite.sql.SqlInsertKeyword; +import org.apache.calcite.sql.SqlIntervalLiteral; +import org.apache.calcite.sql.SqlIntervalQualifier; +import org.apache.calcite.sql.SqlJdbcDataTypeName; +import org.apache.calcite.sql.SqlJdbcFunctionCall; +import org.apache.calcite.sql.SqlJoin; +import org.apache.calcite.sql.SqlJsonConstructorNullClause; +import org.apache.calcite.sql.SqlJsonEncoding; +import org.apache.calcite.sql.SqlJsonExistsErrorBehavior; +import org.apache.calcite.sql.SqlJsonEmptyOrError; +import org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior; +import org.apache.calcite.sql.SqlJsonQueryWrapperBehavior; +import org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior; +import org.apache.calcite.sql.SqlJsonValueReturning; +import org.apache.calcite.sql.SqlKind; +import org.apache.calcite.sql.SqlLiteral; +import org.apache.calcite.sql.SqlMatchRecognize; +import org.apache.calcite.sql.SqlMerge; +import org.apache.calcite.sql.SqlNode; +import org.apache.calcite.sql.SqlNodeList; +import org.apache.calcite.sql.SqlNumericLiteral; +import org.apache.calcite.sql.SqlOperator; +import org.apache.calcite.sql.SqlOrderBy; +import org.apache.calcite.sql.SqlPivot; +import org.apache.calcite.sql.SqlPostfixOperator; +import org.apache.calcite.sql.SqlPrefixOperator; +import org.apache.calcite.sql.SqlRowTypeNameSpec; +import org.apache.calcite.sql.SqlSampleSpec; +import org.apache.calcite.sql.SqlSelect; +import org.apache.calcite.sql.SqlSelectKeyword; +import org.apache.calcite.sql.SqlSetOption; +import org.apache.calcite.sql.SqlSnapshot; +import org.apache.calcite.sql.SqlTableRef; +import org.apache.calcite.sql.SqlTimeLiteral; +import org.apache.calcite.sql.SqlTimestampLiteral; +import org.apache.calcite.sql.SqlTypeNameSpec; +import org.apache.calcite.sql.SqlUnnestOperator; +import org.apache.calcite.sql.SqlUnpivot; +import org.apache.calcite.sql.SqlUpdate; +import org.apache.calcite.sql.SqlUserDefinedTypeNameSpec; +import org.apache.calcite.sql.SqlUtil; +import org.apache.calcite.sql.SqlWindow; +import org.apache.calcite.sql.SqlWith; +import org.apache.calcite.sql.SqlWithItem; +import org.apache.calcite.sql.fun.SqlCase; +import org.apache.calcite.sql.fun.SqlInternalOperators; +import org.apache.calcite.sql.fun.SqlLibraryOperators; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; +import org.apache.calcite.sql.fun.SqlTrimFunction; +import org.apache.calcite.sql.parser.Span; +import org.apache.calcite.sql.parser.SqlAbstractParserImpl; +import org.apache.calcite.sql.parser.SqlParseException; +import org.apache.calcite.sql.parser.SqlParser; +import org.apache.calcite.sql.parser.SqlParserImplFactory; +import org.apache.calcite.sql.parser.SqlParserPos; +import org.apache.calcite.sql.parser.SqlParserUtil; +import org.apache.calcite.sql.type.SqlTypeName; +import org.apache.calcite.sql.validate.SqlConformance; +import org.apache.calcite.util.Glossary; +import org.apache.calcite.util.NlsString; +import org.apache.calcite.util.Pair; +import org.apache.calcite.util.SourceStringReader; +import org.apache.calcite.util.Util; +import org.apache.calcite.util.trace.CalciteTrace; +import org.slf4j.Logger; +import java.io.Reader; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Collections; +import java.util.List; +import java.util.Locale; +import static org.apache.calcite.util.Static.RESOURCE; + +public class IgniteSqlParserImplTokenManager implements IgniteSqlParserImplConstants +{ + final List lexicalStateStack = new ArrayList(); + + void pushState() { + lexicalStateStack.add(curLexState); + } + + void popState() { + SwitchTo(lexicalStateStack.remove(lexicalStateStack.size() - 1)); + } + + void beforeTableName() { + if (curLexState == BQID) { + pushState(); + SwitchTo(BQHID); + } + } + + void afterTableName() { + if (curLexState == BQHID) { + popState(); + } + } + public java.io.PrintStream debugStream = System.out; + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + switch (pos) + { + case 0: + if ((active5 & 0x1fffffc00000L) != 0L || (active10 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + return 86; + } + if ((active10 & 0x80000000000L) != 0L) + { + jjmatchedKind = 781; + return 1; + } + if ((active11 & 0x40000000000000L) != 0L) + return 87; + if ((active11 & 0x20000000L) != 0L) + return 88; + if ((active9 & 0xf000000000000000L) != 0L || (active10 & 0xfffffL) != 0L || (active11 & 0x100L) != 0L) + { + jjmatchedKind = 781; + return 58; + } + if ((active11 & 0x20000000000000L) != 0L) + return 55; + if ((active11 & 0x1000000000000L) != 0L || (active12 & 0x9L) != 0L) + return 84; + if ((active0 & 0x7ffe000000000L) != 0L || (active2 & 0xfffffffffffffff0L) != 0L || (active3 & 0xffffe0007fffffffL) != 0L || (active4 & 0x7ffffe1fffffffL) != 0L || (active5 & 0xffffe00000000000L) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0x7fffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xfffffffffffffffL) != 0L || (active10 & 0x7f27f7fffff00000L) != 0L || (active11 & 0x95L) != 0L) + { + jjmatchedKind = 781; + return 89; + } + if ((active0 & 0xfff8001ffffffff8L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfL) != 0L || (active3 & 0x1fff80000000L) != 0L || (active4 & 0xff800001e0000000L) != 0L || (active5 & 0x3fffffL) != 0L || (active7 & 0x8000000000000000L) != 0L || (active10 & 0xd8000000000000L) != 0L || (active11 & 0x20000000000006aL) != 0L) + return 89; + if ((active11 & 0x400000000000L) != 0L) + return 15; + if ((active11 & 0x10000400000000L) != 0L) + return 90; + return -1; + case 1: + if ((active12 & 0x9L) != 0L) + return 82; + if ((active0 & 0x40007fe000000L) != 0L || (active3 & 0xfc00006000000000L) != 0L || (active4 & 0x200000007ffffL) != 0L || (active5 & 0x78e6001f00000000L) != 0L || (active9 & 0x6000000000L) != 0L || (active10 & 0xa811000000000000L) != 0L || (active11 & 0x40L) != 0L) + return 89; + if ((active0 & 0xfff3fff801fffff0L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xffffffffffffffffL) != 0L || (active3 & 0x3ffff9f7fffffffL) != 0L || (active4 & 0xff7dffffdff80000L) != 0L || (active5 & 0x8719ffe0ffffffffL) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0xffffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xffffff9fffffffffL) != 0L || (active10 & 0x57eeffffffffffffL) != 0L || (active11 & 0x1bfL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 781; + jjmatchedPos = 1; + } + return 89; + } + return -1; + case 2: + if ((active0 & 0xfff3dfef79e98c80L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfe1ff2ffffff09ffL) != 0L || (active3 & 0xfbfeffd77f87ff9fL) != 0L || (active4 & 0x3e7dfffa1fff40ffL) != 0L || (active5 & 0xf795ffeebffe03ffL) != 0L || (active6 & 0xf8fffffdc07fff78L) != 0L || (active7 & 0x1ffffffc3fffffffL) != 0L || (active8 & 0xfffL) != 0L || (active9 & 0xffffffdffff7fffeL) != 0L || (active10 & 0xfffef7ffffffffffL) != 0L || (active11 & 0x1ffL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 781; + jjmatchedPos = 2; + } + return 89; + } + if ((active0 & 0x201004167370L) != 0L || (active2 & 0x1e00d000000f600L) != 0L || (active3 & 0x1000800780060L) != 0L || (active4 & 0xc1000005c0003f00L) != 0L || (active5 & 0x4800104001fc00L) != 0L || (active6 & 0x70000023f800087L) != 0L || (active7 & 0xe0000003c0000000L) != 0L || (active8 & 0xfffffffffffff000L) != 0L || (active9 & 0x80001L) != 0L || (active10 & 0x80000000000L) != 0L) + return 89; + return -1; + case 3: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x99c29fef79e9ece0L) != 0L || (active1 & 0xfff7cfffffffdc01L) != 0L || (active2 & 0xff9ae2fe1fffe80fL) != 0L || (active3 & 0xfbf87f9763f7ffd3L) != 0L || (active4 & 0xbe7d389b80075effL) != 0L || (active5 & 0xf605f86c3f37bbffL) != 0L || (active6 & 0xfe87f7fcff4fff06L) != 0L || (active7 & 0x9febfffdbf7fffffL) != 0L || (active8 & 0xffffffffffffefa6L) != 0L || (active9 & 0xf63fffd00ff7fffdL) != 0L || (active10 & 0xfefe061c3ffd07ffL) != 0L || (active11 & 0xf9L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 781; + jjmatchedPos = 3; + } + return 89; + } + if ((active0 & 0x6631400000000000L) != 0L || (active1 & 0x83000000023feL) != 0L || (active2 & 0x51001e00005f0L) != 0L || (active3 & 0x680401c00000cL) != 0L || (active4 & 0xc7601ff82000L) != 0L || (active5 & 0x190078280c80000L) != 0L || (active6 & 0x78080100300078L) != 0L || (active7 & 0x4014000200800000L) != 0L || (active8 & 0x59L) != 0L || (active9 & 0x9c0000ff0000002L) != 0L || (active10 & 0x100f1e3c002f800L) != 0L || (active11 & 0x106L) != 0L) + return 89; + return -1; + case 4: + if ((active0 & 0xd9e29e2f780120e0L) != 0L || (active1 & 0xfff3affffffe9bfcL) != 0L || (active2 & 0xd592e2ffd3ffe9a7L) != 0L || (active3 & 0xfbd86017637413dbL) != 0L || (active4 & 0x8020aac99fc75ef1L) != 0L || (active5 & 0xc605fb2c2711bbfbL) != 0L || (active6 & 0xfe83d7dcbf4fff74L) != 0L || (active7 & 0x1febf0ddbf1ffeffL) != 0L || (active8 & 0xffffffffffffeea6L) != 0L || (active9 & 0xf6bdffdf88f7f7e1L) != 0L || (active10 & 0xf5de02da3f80f2fcL) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 781; + jjmatchedPos = 4; + } + return 89; + } + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x1c001e8cc00L) != 0L || (active1 & 0x4400000014401L) != 0L || (active2 & 0x2a0800000c000008L) != 0L || (active3 & 0x241f800083ec00L) != 0L || (active4 & 0x3e5d10120000000eL) != 0L || (active5 & 0x3000044018a60004L) != 0L || (active6 & 0x24202040000002L) != 0L || (active7 & 0x80000f2000600100L) != 0L || (active8 & 0x100L) != 0L || (active9 & 0x200000700081cL) != 0L || (active10 & 0xa202404007d0503L) != 0L || (active11 & 0xc0L) != 0L) + return 89; + return -1; + case 5: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0xd9c2878e79c02040L) != 0L || (active1 & 0xfff1afffe67e9bfcL) != 0L || (active2 & 0x192e07fd20fc9a1L) != 0L || (active3 & 0xf9c84d072364834bL) != 0L || (active4 & 0xbc38a2c99fc65ed1L) != 0L || (active5 & 0x6000d12c2710a3b9L) != 0L || (active6 & 0xfe82d7dcaf4dff70L) != 0L || (active7 & 0x19e30e0dbd000effL) != 0L || (active8 & 0xffffffffffffee22L) != 0L || (active9 & 0xf2bdffdf8e17b6d1L) != 0L || (active10 & 0xf7ee028a3fc0f038L) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 781; + jjmatchedPos = 5; + } + return 89; + } + if ((active0 & 0x201821000100a0L) != 0L || (active1 & 0x2000019800000L) != 0L || (active2 & 0xd400028001f02006L) != 0L || (active3 & 0x210301040101090L) != 0L || (active4 & 0x80000010020L) != 0L || (active5 & 0x86052a0000051842L) != 0L || (active6 & 0x1000010020004L) != 0L || (active7 & 0x608f0d0021ff000L) != 0L || (active8 & 0x84L) != 0L || (active9 & 0x400000000e04120L) != 0L || (active10 & 0x100050002002c4L) != 0L) + return 89; + return -1; + case 6: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x40038e79c02040L) != 0L || (active1 & 0x11a7f8f73c9bfcL) != 0L || (active2 & 0x8190007fc20c09a4L) != 0L || (active3 & 0x71c84c0623048102L) != 0L || (active4 & 0xb01880499fc41cd0L) != 0L || (active5 & 0x6000c12c0310a3b9L) != 0L || (active6 & 0x7e80c5d800097f50L) != 0L || (active7 & 0x5e20e898107c85fL) != 0L || (active8 & 0xfffffffffffbee20L) != 0L || (active9 & 0xe281ffcf8ed7b6d1L) != 0L || (active10 & 0xb7fa000a0340f000L) != 0L || (active11 & 0x9L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 781; + jjmatchedPos = 6; + } + return 89; + } + if ((active0 & 0xd982840000000000L) != 0L || (active1 & 0xffe0080700420000L) != 0L || (active2 & 0x2e0001063c001L) != 0L || (active3 & 0x8800010100600249L) != 0L || (active4 & 0xc20228000024201L) != 0L || (active5 & 0x400100024001000L) != 0L || (active6 & 0x80021204af448020L) != 0L || (active7 & 0x180180043c0806a0L) != 0L || (active8 & 0x40002L) != 0L || (active9 & 0x103c001000000000L) != 0L || (active10 & 0x400402803c800038L) != 0L || (active11 & 0x30L) != 0L) + return 89; + return -1; + case 7: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x1040038e79c00000L) != 0L || (active1 & 0xffd1a1fef73c1bfcL) != 0L || (active2 & 0x8180c01782040985L) != 0L || (active3 & 0x71c0440203048002L) != 0L || (active4 & 0x301880409fc40c91L) != 0L || (active5 & 0x4000c02c010003b8L) != 0L || (active6 & 0x7e80c1800e097f40L) != 0L || (active7 & 0x15600e89b807c041L) != 0L || (active8 & 0xfff2ffffff13a000L) != 0L || (active9 & 0xe0b9ff4f8ed3b6d1L) != 0L || (active10 & 0xa7f800082200f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 7) + { + jjmatchedKind = 781; + jjmatchedPos = 7; + } + return 89; + } + if ((active0 & 0x100000000002040L) != 0L || (active1 & 0x60000008000L) != 0L || (active2 & 0x100068400a0020L) != 0L || (active3 & 0x8080420000100L) != 0L || (active4 & 0x8000000900001040L) != 0L || (active5 & 0x200001000210a001L) != 0L || (active6 & 0x45800000010L) != 0L || (active7 & 0x8200000100081eL) != 0L || (active8 & 0xd000000e84e20L) != 0L || (active9 & 0x200008000040000L) != 0L || (active10 & 0x1002000201400000L) != 0L || (active11 & 0x1L) != 0L) + return 89; + return -1; + case 8: + if ((active0 & 0x20610400000L) != 0L || (active1 & 0x108000f03c03f8L) != 0L || (active2 & 0x8080000000000000L) != 0L || (active3 & 0x70c0400202040002L) != 0L || (active4 & 0x18000000040c01L) != 0L || (active5 & 0x2c00000000L) != 0L || (active6 & 0x1880818000017f00L) != 0L || (active7 & 0x60000880040000L) != 0L || (active8 & 0x300004000000L) != 0L || (active9 & 0x2000f00388130410L) != 0L || (active10 & 0x8410000002000000L) != 0L) + return 89; + if ((active0 & 0x1040018869800000L) != 0L || (active1 & 0xffc121fe07001804L) != 0L || (active2 & 0x100c01782040985L) != 0L || (active3 & 0x100040001008000L) != 0L || (active4 & 0x300080409fc00090L) != 0L || (active5 & 0x4000c000010003b8L) != 0L || (active6 & 0x660040100e080040L) != 0L || (active7 & 0x15000e813803c041L) != 0L || (active8 & 0xfffacffffb13ac00L) != 0L || (active9 & 0xc0b90f4c06c0b2c1L) != 0L || (active10 & 0x23e800082000f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 8) + { + jjmatchedKind = 781; + jjmatchedPos = 8; + } + return 89; + } + return -1; + case 9: + if ((active0 & 0x468000000L) != 0L || (active1 & 0x100fe00000a00L) != 0L || (active2 & 0x1102040800L) != 0L || (active4 & 0x804098c00000L) != 0L || (active5 & 0x4000000801000200L) != 0L || (active6 & 0x2200400000000040L) != 0L || (active7 & 0x40100000041L) != 0L || (active8 & 0x2038000L) != 0L || (active9 & 0x80200002008240L) != 0L || (active10 & 0x280000020000000L) != 0L || (active11 & 0x8L) != 0L) + return 89; + if ((active0 & 0x1040018801800000L) != 0L || (active1 & 0xffc02100c73811f4L) != 0L || (active2 & 0x100c00680000185L) != 0L || (active3 & 0x180040001008000L) != 0L || (active4 & 0x3010000007000890L) != 0L || (active5 & 0xc000000001b8L) != 0L || (active6 & 0x440000100e087e00L) != 0L || (active7 & 0x15000a803803c000L) != 0L || (active8 & 0xfffacffff9102c00L) != 0L || (active9 & 0xc0398f4f04c23081L) != 0L || (active10 & 0x216800080000f000L) != 0L) + { + if (jjmatchedPos != 9) + { + jjmatchedKind = 781; + jjmatchedPos = 9; + } + return 89; + } + return -1; + case 10: + if ((active0 & 0x1000010801800000L) != 0L || (active1 & 0xf7c02074863811f0L) != 0L || (active2 & 0x100c00200000181L) != 0L || (active3 & 0x100040000000000L) != 0L || (active4 & 0x3010000000800880L) != 0L || (active5 & 0xc00000000038L) != 0L || (active6 & 0x400000100e007e00L) != 0L || (active7 & 0x11000a003803c000L) != 0L || (active8 & 0xffca8ffff0002c00L) != 0L || (active9 & 0x8038804f00021000L) != 0L || (active10 & 0x2800080000f000L) != 0L) + { + if (jjmatchedPos != 10) + { + jjmatchedKind = 781; + jjmatchedPos = 10; + } + return 89; + } + if ((active0 & 0x40008000000000L) != 0L || (active1 & 0x800018041000004L) != 0L || (active2 & 0x480000004L) != 0L || (active3 & 0x80000001008000L) != 0L || (active4 & 0x7000010L) != 0L || (active5 & 0x180L) != 0L || (active6 & 0x400000000080000L) != 0L || (active7 & 0x400008000000000L) != 0L || (active8 & 0x30400009100000L) != 0L || (active9 & 0x40010f0004c02081L) != 0L || (active10 & 0x2140000000000000L) != 0L) + return 89; + return -1; + case 11: + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x6680000000001000L) != 0L || (active2 & 0x1L) != 0L || (active3 & 0x40000000000L) != 0L || (active4 & 0x1000000000000880L) != 0L || (active5 & 0x800000000020L) != 0L || (active6 & 0x8000000L) != 0L || (active7 & 0x1100080010000000L) != 0L || (active8 & 0x6082800000002800L) != 0L || (active9 & 0x10000100000000L) != 0L || (active10 & 0x8000800000000L) != 0L) + return 89; + if ((active0 & 0x10801800000L) != 0L || (active1 & 0x91402074863801f0L) != 0L || (active2 & 0x100c00200000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004800000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x9f480ffff0000400L) != 0L || (active9 & 0x80288e4e00021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 11) + { + jjmatchedKind = 781; + jjmatchedPos = 11; + } + return 89; + } + return -1; + case 12: + if ((active0 & 0x800000000L) != 0L || (active1 & 0x200000000000L) != 0L || (active2 & 0x100000200000000L) != 0L || (active4 & 0x800000L) != 0L || (active8 & 0x8408000000000400L) != 0L || (active9 & 0x8000000600000000L) != 0L) + return 89; + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xd1400074863801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004000000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x1b400ffff0000000L) != 0L || (active9 & 0x288e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 12; + return 89; + } + return -1; + case 13: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xc1400074862801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x6007800L) != 0L || (active7 & 0x803c000L) != 0L || (active8 & 0x9400ffff0000000L) != 0L || (active9 & 0x88e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 13; + return 89; + } + if ((active1 & 0x1000000000100000L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x10000004000000L) != 0L || (active5 & 0x8L) != 0L || (active6 & 0x4000001000000600L) != 0L || (active7 & 0x20020000000L) != 0L || (active8 & 0x1200000000000000L) != 0L || (active9 & 0x20000000000000L) != 0L) + return 89; + return -1; + case 14: + if ((active0 & 0x1800000L) != 0L || (active1 & 0xc1000050862800f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x1400bfff0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 14; + return 89; + } + if ((active0 & 0x10000000000L) != 0L || (active1 & 0x40002400000100L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active6 & 0x6000000L) != 0L || (active7 & 0x8008000L) != 0L || (active8 & 0x800040000000000L) != 0L || (active9 & 0x8804800021000L) != 0L) + return 89; + return -1; + case 15: + if ((active0 & 0x1000000L) != 0L || (active1 & 0xc1000050000800e0L) != 0L || (active2 & 0x180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x14003ff00000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 15) + { + jjmatchedKind = 781; + jjmatchedPos = 15; + } + return 89; + } + if ((active0 & 0x800000L) != 0L || (active1 & 0x86200010L) != 0L || (active2 & 0xc00000000000L) != 0L || (active8 & 0x800f0000000L) != 0L) + return 89; + return -1; + case 16: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000010040000e0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x1400078e0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 16) + { + jjmatchedKind = 781; + jjmatchedPos = 16; + } + return 89; + } + if ((active1 & 0x4000004000080000L) != 0L || (active5 & 0x400000000000L) != 0L || (active7 & 0x20000L) != 0L || (active8 & 0x38700000000L) != 0L) + return 89; + return -1; + case 17: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x140015ee0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 17; + return 89; + } + if ((active1 & 0x1000000040L) != 0L || (active8 & 0x2000000000L) != 0L) + return 89; + return -1; + case 18: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x106e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 18) + { + jjmatchedKind = 781; + jjmatchedPos = 18; + } + return 89; + } + if ((active8 & 0x140005800000000L) != 0L || (active9 & 0x20000000000L) != 0L) + return 89; + return -1; + case 19: + if ((active1 & 0x80L) != 0L || (active5 & 0x10L) != 0L || (active7 & 0x4000L) != 0L) + return 89; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x8100000004000020L) != 0L || (active2 & 0x800000000180L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x10000L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 19; + return 89; + } + return -1; + case 20: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x180L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 20; + return 89; + } + if ((active0 & 0x1000000L) != 0L || (active1 & 0x4000020L) != 0L || (active2 & 0x800000000000L) != 0L || (active7 & 0x10000L) != 0L) + return 89; + return -1; + case 21: + if ((active2 & 0x80L) != 0L || (active9 & 0x40000000000L) != 0L || (active10 & 0x6000L) != 0L) + return 89; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 21; + return 89; + } + return -1; + case 22: + if ((active6 & 0x2000L) != 0L) + return 89; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 22; + return 89; + } + return -1; + case 23: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000001000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 23; + return 89; + } + if ((active8 & 0x20000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x8000L) != 0L) + return 89; + return -1; + case 24: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x1800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 24; + return 89; + } + if ((active6 & 0x4000L) != 0L || (active10 & 0x1000L) != 0L) + return 89; + return -1; + case 25: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active8 & 0x1600000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 25; + return 89; + } + if ((active6 & 0x1800L) != 0L || (active8 & 0x100c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + return 89; + return -1; + case 26: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 26; + return 89; + } + if ((active2 & 0x100L) != 0L || (active8 & 0x600000000L) != 0L) + return 89; + return -1; + case 27: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 27; + return 89; + } + return -1; + case 28: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 28; + return 89; + } + if ((active8 & 0x1000000000L) != 0L) + return 89; + return -1; + case 29: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 29; + return 89; + } + return -1; + case 30: + if ((active1 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 30; + return 89; + } + if ((active1 & 0x100000000000000L) != 0L) + return 89; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_1(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12), pos + 1); +} +private final int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private final int jjStartNfaWithStates_1(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_1(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_1() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 1; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000L, 0x0L); + case 34: + return jjStartNfaWithStates_1(0, 758, 87); + case 36: + return jjStartNfaWithStates_1(0, 761, 89); + case 37: + return jjStopAtPos(0, 753); + case 39: + return jjStartNfaWithStates_1(0, 757, 55); + case 40: + return jjStopAtPos(0, 727); + case 41: + return jjStopAtPos(0, 728); + case 42: + jjmatchedKind = 751; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L); + case 43: + return jjStopAtPos(0, 749); + case 44: + return jjStopAtPos(0, 739); + case 45: + return jjStartNfaWithStates_1(0, 750, 15); + case 46: + jjmatchedKind = 738; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x10000000000000L, 0x0L); + case 47: + jjmatchedKind = 752; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x9L); + case 58: + jjmatchedKind = 744; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L); + case 59: + return jjStopAtPos(0, 737); + case 60: + jjmatchedKind = 742; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xa0000000000L, 0x0L); + case 61: + jjmatchedKind = 740; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000L, 0x0L); + case 62: + jjmatchedKind = 741; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x40000000000L, 0x0L); + case 63: + return jjStopAtPos(0, 743); + case 91: + return jjStopAtPos(0, 735); + case 93: + return jjStopAtPos(0, 736); + case 94: + return jjStopAtPos(0, 760); + case 65: + case 97: + jjmatchedKind = 3; + return jjMoveStringLiteralDfa1_1(0x1ffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x18000000000000L, 0x40L, 0x0L); + case 66: + case 98: + return jjMoveStringLiteralDfa1_1(0x7ffe000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L, 0x0L); + case 67: + case 99: + jjmatchedKind = 51; + return jjMoveStringLiteralDfa1_1(0xfff0000000000000L, 0xffffffffffffffffL, 0xfL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xc0000000000000L, 0x28L, 0x0L); + case 68: + case 100: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0xfffffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000000L, 0x0L, 0x0L); + case 69: + case 101: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0xffff000000000000L, 0x3ffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L, 0x0L); + case 70: + case 102: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x7ffffc00L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 71: + case 103: + jjmatchedKind = 223; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x1fff00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 72: + case 104: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x7e00000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 73: + case 105: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0xfff8000000000000L, 0x7ffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2801000000000000L, 0x0L, 0x0L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x1ff80000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 75: + case 107: + jjmatchedKind = 285; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x1c0000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L, 0x0L); + case 76: + case 108: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffe00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000000L, 0x0L, 0x0L); + case 77: + case 109: + jjmatchedKind = 311; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0xff00000000000000L, 0x3fffffL, 0x0L, 0x8000000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 78: + case 110: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1fffffc00000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000000L, 0x0L, 0x0L); + case 79: + case 111: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xffffe00000000000L, 0x7fL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 80: + case 112: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1ffffffffff80L, 0x0L, 0x0L, 0x0L, 0x1000000000000000L, 0x1L, 0x0L); + case 81: + case 113: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80L, 0x0L); + case 82: + case 114: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffc000000000000L, 0x7ffffffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 83: + case 115: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffff800000000L, 0xffffffffffffffffL, 0xffffffL, 0x800000000000L, 0x14L, 0x0L); + case 84: + case 116: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffffffff000000L, 0x2000000000000L, 0x0L, 0x0L); + case 85: + case 117: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xf000000000000000L, 0xfffffL, 0x100L, 0x0L); + case 86: + case 118: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x20000007ff00000L, 0x0L, 0x0L); + case 87: + case 119: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2007ff80000000L, 0x0L, 0x0L); + case 88: + case 120: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80000000000L, 0x0L, 0x0L); + case 89: + case 121: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x300000000000L, 0x0L, 0x0L); + case 90: + case 122: + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000L, 0x0L, 0x0L); + case 123: + return jjStartNfaWithStates_1(0, 733, 88); + case 124: + jjmatchedKind = 759; + return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L); + case 125: + return jjStopAtPos(0, 734); + case 126: + return jjStopAtPos(0, 2); + default : + return jjMoveNfa_1(0, 0); + } +} +private final int jjMoveStringLiteralDfa1_1(long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 1; + } + switch(curChar) + { + case 42: + if ((active12 & 0x8L) != 0L) + { + jjmatchedKind = 771; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0x1L); + case 46: + if ((active11 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 756); + break; + case 47: + if ((active12 & 0x2L) != 0L) + return jjStopAtPos(1, 769); + break; + case 58: + if ((active11 & 0x400000000000000L) != 0L) + return jjStopAtPos(1, 762); + break; + case 61: + if ((active11 & 0x20000000000L) != 0L) + return jjStopAtPos(1, 745); + else if ((active11 & 0x40000000000L) != 0L) + return jjStopAtPos(1, 746); + else if ((active11 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 748); + break; + case 62: + if ((active11 & 0x80000000000L) != 0L) + return jjStopAtPos(1, 747); + else if ((active11 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 755); + break; + case 65: + case 97: + return jjMoveStringLiteralDfa2_1(active0, 0x1ff0000000000000L, active1, 0L, active2, 0x10000000007f0L, active3, 0x200000000400L, active4, 0xff0000fe00080000L, active5, 0x7c00000L, active6, 0xc0000007fff80L, active7, 0x800000000L, active8, 0L, active9, 0x7000000L, active10, 0x13c400000ff00000L, active11, 0x1L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa2_1(active0, 0x70L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa2_1(active0, 0x80L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1c00018000000L, active6, 0L, active7, 0x1ff000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x4L, active12, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa2_1(active0, 0x700L, active1, 0L, active2, 0L, active3, 0x8000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa2_1(active0, 0xe00007e000000000L, active1, 0L, active2, 0x3fffff800L, active3, 0xf00000800L, active4, 0x1f01c0000000L, active5, 0xe000007fL, active6, 0xfff000003f800000L, active7, 0x7fffe000001fffffL, active8, 0L, active9, 0x1000000008000000L, active10, 0x2b000b0000000L, active11, 0x10L, active12, 0L); + case 70: + case 102: + if ((active5 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 369; + jjmatchedPos = 1; + } + else if ((active10 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(1, 688, 89); + return jjMoveStringLiteralDfa2_1(active0, 0x800L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x4000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000000000000L, active11, 0L, active12, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x10000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x7ffL, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1L, active9, 0x10000000L, active10, 0x700000000L, active11, 0L, active12, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa2_1(active0, 0x380000000000L, active1, 0L, active2, 0x7c00000000L, active3, 0x40000000f000L, active4, 0x1e00000000000L, active5, 0x3f80L, active6, 0x40000000L, active7, 0x8000000000200000L, active8, 0xeL, active9, 0x1fe0000000L, active10, 0xf840000000L, active11, 0x2L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa2_1(active0, 0x40000001f000L, active1, 0x7800L, active2, 0x6000000000000L, active3, 0x20001000030000L, active4, 0L, active5, 0x8000000000000L, active6, 0x380000000L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x8000000000000L, active3, 0x3c0000000000000L, active4, 0L, active5, 0x10000000000000L, active6, 0L, active7, 0L, active8, 0x20L, active9, 0L, active10, 0x80000000000L, active11, 0L, active12, 0L); + case 78: + case 110: + if ((active3 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 250; + jjmatchedPos = 1; + } + else if ((active4 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(1, 305, 89); + else if ((active5 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 373; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0x60000L, active1, 0L, active2, 0x1f0000000000000L, active3, 0xf800000000000000L, active4, 0x7fffL, active5, 0xc0000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe000000000000000L, active10, 0x2c0000000000007fL, active11, 0L, active12, 0L); + case 79: + case 111: + if ((active3 & 0x2000000000L) != 0L) + { + jjmatchedKind = 229; + jjmatchedPos = 1; + } + else if ((active5 & 0x100000000L) != 0L) + { + jjmatchedKind = 352; + jjmatchedPos = 1; + } + else if ((active9 & 0x2000000000L) != 0L) + { + jjmatchedKind = 613; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0x1800000000000L, active1, 0x1ffffffff8000L, active2, 0xf8000000000L, active3, 0x7804000fc0000L, active4, 0x7c000000100000L, active5, 0x1e000fc000L, active6, 0x3c00000000L, active7, 0x3ff800000L, active8, 0xc0L, active9, 0x4000000000L, active10, 0xc000410000000000L, active11, 0x28L, active12, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa2_1(active0, 0x80000L, active1, 0L, active2, 0x200000000000000L, active3, 0L, active4, 0L, active5, 0x700000000000000L, active6, 0L, active7, 0L, active8, 0xf00L, active9, 0L, active10, 0x380L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x400000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xfffffffffffff000L, active9, 0x3L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active5 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 379; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0x2000001f00000L, active1, 0x6000000000000L, active2, 0x800100000000000L, active3, 0x1f800f000000L, active4, 0L, active5, 0x7000000000000000L, active6, 0xffc000000000L, active7, 0L, active8, 0L, active9, 0x3ffff8000000000L, active10, 0x20060000000000L, active11, 0L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + else if ((active4 & 0x8000L) != 0L) + { + jjmatchedKind = 271; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0x7c000000L, active1, 0L, active2, 0x1000000000000000L, active3, 0L, active4, 0x1fe70000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x1fc00L, active11, 0x40L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_1(active0, 0x700000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000006000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xffcL, active10, 0x100000000e0000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa2_1(active0, 0x800000000L, active1, 0xfff8000000000000L, active2, 0x7L, active3, 0x70000000L, active4, 0L, active5, 0x1f8000300000L, active6, 0x3000000000007L, active7, 0x400000000L, active8, 0L, active9, 0x4000000000ff000L, active10, 0L, active11, 0x180L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa2_1(active0, 0x1000000000L, active1, 0L, active2, 0x2000000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x78L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0xc000000000000000L, active3, 0x3ffL, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(1, 50, 89); + return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0xe00000000008L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800000000f00000L, active10, 0L, active11, 0L, active12, 0L); + case 124: + if ((active11 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 754); + break; + default : + break; + } + return jjStartNfa_1(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_1(0, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 2; + } + switch(curChar) + { + case 43: + if ((active12 & 0x1L) != 0L) + return jjStopAtPos(2, 768); + break; + case 65: + case 97: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_1(2, 8, 89); + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x9bffL, active2, 0x400000800L, active3, 0x18003000000L, active4, 0x30000000000L, active5, 0x1L, active6, 0x72000180000000L, active7, 0x203000000000L, active8, 0x120L, active9, 0x1ff800000003cL, active10, 0x320000000400L, active11, 0x4L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x8000000010000L, active2, 0L, active3, 0L, active4, 0x200200000000L, active5, 0L, active6, 0x1000000000000L, active7, 0L, active8, 0L, active9, 0x200000000703f000L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(2, 26, 89); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0xd01100000000e008L, active3, 0x3800000000000003L, active4, 0x3c000000000000L, active5, 0x400000000080L, active6, 0x80000000000000L, active7, 0x3c00000000000L, active8, 0L, active9, 0xc000000000040000L, active10, 0x4c4000000000000L, active11, 0L, active12, 0L); + case 68: + case 100: + if ((active0 & 0x200L) != 0L) + return jjStartNfaWithStates_1(2, 9, 89); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(2, 17, 89); + else if ((active2 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 181; + jjmatchedPos = 2; + } + else if ((active5 & 0x4000L) != 0L) + { + jjmatchedKind = 334; + jjmatchedPos = 2; + } + else if ((active5 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(2, 371, 89); + else if ((active6 & 0x80L) != 0L) + return jjStartNfaWithStates_1(2, 391, 89); + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0x1c0000000000000L, active3, 0x4000000000000000L, active4, 0L, active5, 0x7000000000018000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x800000800000081L, active11, 0L, active12, 0L); + case 69: + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(2, 20, 89); + else if ((active5 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(2, 374, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x2000008000000L, active1, 0x2000000000400L, active2, 0x2002000000000000L, active3, 0x840000400000cL, active4, 0L, active5, 0x100000000000000L, active6, 0xfc000000078L, active7, 0x4000000000000L, active8, 0xe00L, active9, 0x2000030000000L, active10, 0x7c000f800L, active11, 0x80L, active12, 0L); + case 70: + case 102: + if ((active6 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 440; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x2000000000L, active1, 0L, active2, 0x7f0000L, active3, 0L, active4, 0x40000000000L, active5, 0x4000000000000L, active6, 0x600000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000000e0000L, active11, 0L, active12, 0L); + case 71: + case 103: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(2, 36, 89); + else if ((active4 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(2, 290, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x9c000000000L, active1, 0L, active2, 0x800000L, active3, 0L, active4, 0L, active5, 0L, active6, 0xf800000000000000L, active7, 0x20000fL, active8, 0L, active9, 0L, active10, 0x4000000000000000L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000002008000000L, active6, 0L, active7, 0xc000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 73: + case 105: + if ((active6 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(2, 417, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x6000000000000000L, active1, 0L, active2, 0L, active3, 0x8020000000000010L, active4, 0x100001L, active5, 0x10004000000000L, active6, 0x700000000000L, active7, 0x400000L, active8, 0x10L, active9, 0xfc000000000000L, active10, 0x20040000010006L, active11, 0x100L, active12, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0xc00000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L, active12, 0L); + case 76: + case 108: + if ((active0 & 0x1000L) != 0L) + { + jjmatchedKind = 12; + jjmatchedPos = 2; + } + else if ((active8 & 0x1000L) != 0L) + { + jjmatchedKind = 524; + jjmatchedPos = 2; + } + else if ((active10 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(2, 683, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x30000000006000L, active1, 0x1fe0000L, active2, 0x1000000L, active3, 0x800010041400L, active4, 0L, active5, 0x80078010100300L, active6, 0L, active7, 0x18000003800030L, active8, 0xffffffffffffe000L, active9, 0x1L, active10, 0xa200000000700000L, active11, 0x2L, active12, 0L); + case 77: + case 109: + if ((active9 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(2, 595, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x400L, active1, 0x1000001e000000L, active2, 0x8000000000L, active3, 0xc0000000000000L, active4, 0x1000000000000L, active5, 0x180000e00002L, active6, 0L, active7, 0L, active8, 0x46L, active9, 0x400000fc8100000L, active10, 0x2800000000000L, active11, 0x20L, active12, 0L); + case 78: + case 110: + if ((active5 & 0x400L) != 0L) + { + jjmatchedKind = 330; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x8000100000000000L, active1, 0xfffe0000000L, active2, 0xe00002000000L, active3, 0x10000320002000L, active4, 0x80800000002L, active5, 0x201063800L, active6, 0xc000000000000L, active7, 0x8020000400000000L, active8, 0L, active9, 0x1000000000L, active10, 0x401000000060L, active11, 0x8L, active12, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa3_1(active0, 0xc00100000000L, active1, 0x4000000006000L, active2, 0x200100000000000L, active3, 0x1e1408030000L, active4, 0x1fe70004L, active5, 0L, active6, 0x800000000000L, active7, 0xf0000000000L, active8, 0x1L, active9, 0L, active10, 0x10000000000000L, active11, 0L, active12, 0L); + case 80: + case 112: + if ((active3 & 0x20L) != 0L) + { + jjmatchedKind = 197; + jjmatchedPos = 2; + } + else if ((active3 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(2, 240, 89); + else if ((active4 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(2, 312, 89); + return jjMoveStringLiteralDfa3_1(active0, 0x80000L, active1, 0L, active2, 0x8000004000000L, active3, 0x300000000000040L, active4, 0x8L, active5, 0L, active6, 0L, active7, 0x400000000000c0L, active8, 0L, active9, 0x800004000000000L, active10, 0x110L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active3 & 0x80000L) != 0L) + { + jjmatchedKind = 211; + jjmatchedPos = 2; + } + else if ((active6 & 0x800000L) != 0L) + { + jjmatchedKind = 407; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x40020001e00000L, active1, 0xffe0300000000000L, active2, 0x800000018000007L, active3, 0x70c000L, active4, 0x1000000000L, active5, 0xc00080004L, active6, 0x43f01ff00L, active7, 0x700100000000000L, active8, 0L, active9, 0x702L, active10, 0x100001003f800000L, active11, 0x10L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x10L) != 0L) + { + jjmatchedKind = 4; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x780000030000060L, active1, 0L, active2, 0x40079e0000000L, active3, 0x40000000L, active4, 0x60000000f0L, active5, 0x20000038L, active6, 0x18001e0000L, active7, 0x1800000000001f00L, active8, 0L, active9, 0x1000000000e00000L, active10, 0x200L, active11, 0x1L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(2, 45, 89); + else if ((active2 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(2, 168, 89); + else if ((active3 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(2, 227, 89); + else if ((active4 & 0x100L) != 0L) + { + jjmatchedKind = 264; + jjmatchedPos = 2; + } + else if ((active5 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(2, 356, 89); + else if ((active6 & 0x1L) != 0L) + { + jjmatchedKind = 384; + jjmatchedPos = 2; + } + else if ((active7 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 509; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x1801040e00008880L, active1, 0L, active2, 0x2000001f0L, active3, 0x4000000b80L, active4, 0x3e00008000003e00L, active5, 0x601800006000040L, active6, 0x600006L, active7, 0x40000000000fe000L, active8, 0L, active9, 0L, active10, 0x10000e000000000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x400000000000L, active2, 0x400020000000000L, active3, 0x6000000800000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000000L, active8, 0x80L, active9, 0x300000000000000L, active10, 0L, active11, 0L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x1800000000000L, active2, 0L, active3, 0x200000000000L, active4, 0x100000084000L, active5, 0L, active6, 0x40000000L, active7, 0x800100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 87: + case 119: + if ((active2 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(2, 170, 89); + else if ((active5 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(2, 350, 89); + else if ((active7 & 0x40000000L) != 0L) + { + jjmatchedKind = 478; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x40000000000000L, active5, 0L, active6, 0x2000000000L, active7, 0x380000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + if ((active4 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 318; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x80000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(2, 18, 89); + else if ((active2 & 0x200L) != 0L) + { + jjmatchedKind = 137; + jjmatchedPos = 2; + } + else if ((active2 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(2, 171, 89); + else if ((active4 & 0x40000000L) != 0L) + { + jjmatchedKind = 286; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_1(active0, 0x40000000L, active1, 0L, active2, 0x400L, active3, 0L, active4, 0x180000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800L, active10, 0L, active11, 0x40L, active12, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + default : + break; + } + return jjStartNfa_1(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_1(1, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 3; + } + switch(curChar) + { + case 45: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 49: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x40000L, active11, 0L); + case 51: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000L, active11, 0L); + case 56: + if ((active10 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(3, 657, 89); + break; + case 95: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0x180000000000000L, active3, 0L, active4, 0x180000000L, active5, 0x2000000000L, active6, 0L, active7, 0x180000000L, active8, 0xffffffffffff0000L, active9, 0x4000000001L, active10, 0x1800000L, active11, 0L); + case 65: + case 97: + if ((active2 & 0x10L) != 0L) + { + jjmatchedKind = 132; + jjmatchedPos = 3; + } + else if ((active4 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(3, 275, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x1802100001e10000L, active1, 0x3800000000000L, active2, 0x1400e08800032020L, active3, 0x12000L, active4, 0x3c000000000000L, active5, 0x8000000L, active6, 0x7f00L, active7, 0x40000000000010L, active8, 0L, active9, 0x2000000000000L, active10, 0x11000000000000a0L, active11, 0L); + case 66: + case 98: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(3, 46, 89); + else if ((active1 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(3, 77, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0x20000000000L, active3, 0x1000000000L, active4, 0L, active5, 0x80000000002L, active6, 0L, active7, 0L, active8, 0L, active9, 0x400000000000000L, active10, 0x2000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x20000000L) != 0L) + { + jjmatchedKind = 157; + jjmatchedPos = 3; + } + else if ((active3 & 0x4L) != 0L) + { + jjmatchedKind = 194; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_1(active0, 0x180000000000000L, active1, 0x400L, active2, 0x2000011c0000000L, active3, 0x21000808L, active4, 0x3e00000000000000L, active5, 0L, active6, 0x81c08f020000L, active7, 0L, active8, 0xf00L, active9, 0x1000000000041000L, active10, 0x4000000L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(3, 239, 89); + else if ((active4 & 0x10000000000L) != 0L) + { + jjmatchedKind = 296; + jjmatchedPos = 3; + } + else if ((active6 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 436; + jjmatchedPos = 3; + } + else if ((active11 & 0x100L) != 0L) + return jjStartNfaWithStates_1(3, 712, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x40000000000000L, active1, 0xe0000000L, active2, 0L, active3, 0L, active4, 0x20000010000L, active5, 0L, active6, 0x20000000000000L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x1000000000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 57, 89); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 115, 89); + else if ((active2 & 0x40L) != 0L) + { + jjmatchedKind = 134; + jjmatchedPos = 3; + } + else if ((active2 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 178, 89); + else if ((active3 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(3, 218, 89); + else if ((active4 & 0x400000000000L) != 0L) + { + jjmatchedKind = 302; + jjmatchedPos = 3; + } + else if ((active5 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(3, 339, 89); + else if ((active5 & 0x400000L) != 0L) + { + jjmatchedKind = 342; + jjmatchedPos = 3; + } + else if ((active5 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(3, 353, 89); + else if ((active7 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(3, 471, 89); + else if ((active8 & 0x8L) != 0L) + return jjStartNfaWithStates_1(3, 515, 89); + else if ((active8 & 0x40L) != 0L) + return jjStartNfaWithStates_1(3, 518, 89); + else if ((active9 & 0x40000000L) != 0L) + { + jjmatchedKind = 606; + jjmatchedPos = 3; + } + else if ((active9 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 632, 89); + else if ((active9 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 635, 89); + else if ((active10 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(3, 686, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x10008820L, active1, 0x10000000000000L, active2, 0xc0000002090c0180L, active3, 0xc0000300200180L, active4, 0x40908200001e32L, active5, 0xb001b00000800000L, active6, 0x600002000000002L, active7, 0x800c800000160L, active8, 0x2000L, active9, 0xf80000100L, active10, 0x800000000000341L, active11, 0L); + case 70: + case 102: + if ((active7 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 500, 89); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0x400000000L, active3, 0L, active4, 0x81800000000L, active5, 0x4L, active6, 0x4000000000000L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x4000000000000400L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 48, 89); + else if ((active2 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 176, 89); + else if ((active6 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(3, 405, 89); + else if ((active10 & 0x2000000000L) != 0L) + { + jjmatchedKind = 677; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_1(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x40L, active6, 0L, active7, 0x200000L, active8, 0L, active9, 0L, active10, 0xc000c000000000L, active11, 0L); + case 73: + case 105: + if ((active10 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(3, 687, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x9c020000480L, active1, 0x1L, active2, 0x10704000L, active3, 0x4000200040000000L, active4, 0x1000000000000L, active5, 0x4600000002008000L, active6, 0x1810000000L, active7, 0x100000000000000L, active8, 0x2L, active9, 0x8000000200L, active10, 0x2008000000000010L, active11, 0L); + case 75: + case 107: + if ((active6 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 435, 89); + else if ((active7 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 498, 89); + else if ((active10 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(3, 671, 89); + else if ((active10 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(3, 680, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x20000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0x4000000000000L, active11, 0L); + case 76: + case 108: + if ((active0 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + } + else if ((active0 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 61; + jjmatchedPos = 3; + } + else if ((active3 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(3, 220, 89); + else if ((active5 & 0x8000000000L) != 0L) + { + jjmatchedKind = 359; + jjmatchedPos = 3; + } + else if ((active6 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 438, 89); + else if ((active11 & 0x2L) != 0L) + return jjStartNfaWithStates_1(3, 705, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x4020800000080000L, active1, 0x7e8000L, active2, 0x8808L, active3, 0x1900000000040043L, active4, 0x40000L, active5, 0x74000000300L, active6, 0x1000000000000L, active7, 0x3003000080L, active8, 0x20L, active9, 0x7000800L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active3 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(3, 219, 89); + else if ((active9 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 630; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_1(active0, 0x140000000L, active1, 0x1e000000L, active2, 0x2000000000000L, active3, 0x402100000L, active4, 0L, active5, 0xc00000000L, active6, 0x100020000000L, active7, 0L, active8, 0L, active9, 0x80000000102000L, active10, 0x10000000000000L, active11, 0L); + case 78: + case 110: + if ((active4 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(3, 276, 89); + else if ((active4 & 0x200000L) != 0L) + { + jjmatchedKind = 277; + jjmatchedPos = 3; + } + else if ((active5 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 376, 89); + else if ((active6 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(3, 416, 89); + else if ((active9 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(3, 604, 89); + else if ((active10 & 0x100000000L) != 0L) + { + jjmatchedKind = 672; + jjmatchedPos = 3; + } + else if ((active11 & 0x4L) != 0L) + return jjStartNfaWithStates_1(3, 706, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x20008000000L, active1, 0x400700000000L, active2, 0L, active3, 0x8018000800000L, active4, 0x1fc00000L, active5, 0L, active6, 0L, active7, 0x400000000L, active8, 0L, active9, 0x201ff0000000000L, active10, 0x200010008L, active11, 0x40L); + case 79: + case 111: + if ((active3 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(3, 230, 89); + else if ((active4 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(3, 269, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x2000006040L, active1, 0x10000L, active2, 0x810000000000000L, active3, 0x210000000020000L, active4, 0x4000L, active5, 0x11000000L, active6, 0x200040000000L, active7, 0xd00000100000L, active8, 0L, active9, 0xe000000000000000L, active10, 0x8000000000000002L, active11, 0L); + case 80: + case 112: + if ((active2 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(3, 172, 89); + else if ((active8 & 0x10L) != 0L) + return jjStartNfaWithStates_1(3, 516, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0x2000000000L, active3, 0L, active4, 0L, active5, 0x200000L, active6, 0x20000000004L, active7, 0xf0000000200L, active8, 0x4L, active9, 0x8000000L, active10, 0x2020000000000L, active11, 0x20L); + case 81: + case 113: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x2L) != 0L) + { + jjmatchedKind = 65; + jjmatchedPos = 3; + } + else if ((active1 & 0x100000000000L) != 0L) + { + jjmatchedKind = 108; + jjmatchedPos = 3; + } + else if ((active3 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 241; + jjmatchedPos = 3; + } + else if ((active6 & 0x8L) != 0L) + { + jjmatchedKind = 387; + jjmatchedPos = 3; + } + else if ((active10 & 0x800L) != 0L) + { + jjmatchedKind = 651; + jjmatchedPos = 3; + } + else if ((active10 & 0x100000000000L) != 0L) + { + jjmatchedKind = 684; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_1(active0, 0x600000000L, active1, 0xffe02000000003fcL, active2, 0x2000000000800001L, active3, 0x2004400000000200L, active4, 0x200000000000L, active5, 0x80L, active6, 0xf802000000000070L, active7, 0x20000000000fL, active8, 0x80L, active9, 0x4L, active10, 0x40020040000f000L, active11, 0x80L); + case 83: + case 115: + if ((active2 & 0x400L) != 0L) + return jjStartNfaWithStates_1(3, 138, 89); + else if ((active7 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(3, 481, 89); + else if ((active7 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 510, 89); + else if ((active9 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(3, 605, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x401f800005800L, active2, 0x2000006L, active3, 0xc410L, active4, 0L, active5, 0x4000000000039L, active6, 0x400000c0000L, active7, 0x1820000000000000L, active8, 0x4000L, active9, 0x3c000L, active10, 0x30000000L, active11, 0x1L); + case 84: + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 58, 89); + else if ((active4 & 0x2000000000L) != 0L) + { + jjmatchedKind = 293; + jjmatchedPos = 3; + } + else if ((active4 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(3, 298, 89); + else if ((active5 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(3, 351, 89); + else if ((active5 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 372, 89); + else if ((active6 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(3, 404, 89); + else if ((active9 & 0x2L) != 0L) + return jjStartNfaWithStates_1(3, 577, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x8000000000000000L, active1, 0x60000000000L, active2, 0x8004004000000L, active3, 0x8000000000401000L, active4, 0x40000000c1L, active5, 0x20160000L, active6, 0x400418000L, active7, 0x100003c000c00L, active8, 0L, active9, 0xe00038L, active10, 0x20040800000000L, active11, 0x8L); + case 85: + case 117: + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x1800000L, active2, 0L, active3, 0x1e0000000000L, active4, 0xcL, active5, 0x400004011800L, active6, 0x80000000000000L, active7, 0x80820000000ff000L, active8, 0L, active9, 0x400L, active10, 0x200000000700000L, active11, 0L); + case 86: + case 118: + if ((active6 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(3, 427, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x80000000000L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x2000L, active6, 0x400000000000L, active7, 0x600000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x10L); + case 87: + case 119: + if ((active8 & 0x1L) != 0L) + return jjStartNfaWithStates_1(3, 512, 89); + else if ((active10 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(3, 670, 89); + return jjMoveStringLiteralDfa4_1(active0, 0x40000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active5 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(3, 375, 89); + return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x20000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000L, active10, 0x8000000L, active11, 0L); + default : + break; + } + return jjStartNfa_1(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(2, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 4; + } + switch(curChar) + { + case 50: + if ((active10 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(4, 659, 89); + break; + case 54: + if ((active10 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(4, 658, 89); + break; + case 95: + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x10000000000004L, active2, 0L, active3, 0x1000000L, active4, 0x80401fc00000L, active5, 0L, active6, 0xf800000000000000L, active7, 0xfL, active8, 0L, active9, 0x80000000000000L, active10, 0x10000000000f000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa5_1(active0, 0x180000000000000L, active1, 0x200063e03f8L, active2, 0x2000008000L, active3, 0x401000100240L, active4, 0x80002000000400c0L, active5, 0x10c00002038L, active6, 0x120000020000L, active7, 0x1000010000004e0L, active8, 0x8000L, active9, 0x1000000000000100L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active5 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(4, 348, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0x20L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1000000L, active8, 0x1f0000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active11 & 0x40L) != 0L) + return jjStartNfaWithStates_1(4, 710, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x2000L, active1, 0L, active2, 0L, active3, 0x4000000000000000L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0x8200080000000L, active8, 0x600080L, active9, 0x200000000000400L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(4, 215, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x2000000000000L, active1, 0L, active2, 0x10000000002000L, active3, 0xc0000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active1 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(4, 78, 89); + else if ((active2 & 0x8L) != 0L) + return jjStartNfaWithStates_1(4, 131, 89); + else if ((active3 & 0x400L) != 0L) + return jjStartNfaWithStates_1(4, 202, 89); + else if ((active3 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 245, 89); + else if ((active4 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(4, 292, 89); + else if ((active5 & 0x4L) != 0L) + return jjStartNfaWithStates_1(4, 322, 89); + else if ((active5 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(4, 358, 89); + else if ((active6 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 434, 89); + else if ((active7 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(4, 470, 89); + else if ((active7 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(4, 485, 89); + else if ((active7 & 0x10000000000L) != 0L) + { + jjmatchedKind = 488; + jjmatchedPos = 4; + } + else if ((active8 & 0x100L) != 0L) + return jjStartNfaWithStates_1(4, 520, 89); + else if ((active9 & 0x8L) != 0L) + { + jjmatchedKind = 579; + jjmatchedPos = 4; + } + else if ((active9 & 0x800L) != 0L) + return jjStartNfaWithStates_1(4, 587, 89); + else if ((active9 & 0x1000000L) != 0L) + { + jjmatchedKind = 600; + jjmatchedPos = 4; + } + else if ((active10 & 0x400L) != 0L) + return jjStartNfaWithStates_1(4, 650, 89); + else if ((active10 & 0x100000L) != 0L) + { + jjmatchedKind = 660; + jjmatchedPos = 4; + } + else if ((active10 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(4, 674, 89); + else if ((active10 & 0x40000000000L) != 0L) + { + jjmatchedKind = 682; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_1(active0, 0x20840000000000L, active1, 0xffe0280700408000L, active2, 0x42000002800001L, active3, 0x2100000402001000L, active4, 0x20000L, active5, 0x4080000000202L, active6, 0x84c00f400000L, active7, 0x6800e0000000200L, active8, 0L, active9, 0x6f440d0L, active10, 0x2e0000200600000L, active11, 0L); + case 70: + case 102: + if ((active2 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(4, 155, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0L, active5, 0x8000L, active6, 0L, active7, 0L, active8, 0x4000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active10 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(4, 656, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x20000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x200L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(4, 154, 89); + else if ((active2 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 185, 89); + else if ((active3 & 0x800L) != 0L) + return jjStartNfaWithStates_1(4, 203, 89); + else if ((active4 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 313; + jjmatchedPos = 4; + } + else if ((active5 & 0x20000L) != 0L) + { + jjmatchedKind = 337; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x3c00000000000000L, active5, 0x40000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x804000000L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa5_1(active0, 0x4040000700000000L, active1, 0x400f8000000L, active2, 0xc000000000L, active3, 0x8000000000200000L, active4, 0x20000000001L, active5, 0x20020100100L, active6, 0x1410480058000L, active7, 0x182100043c000000L, active8, 0x1fff8000e00L, active9, 0x1000000020L, active10, 0x401000403a000000L, active11, 0x18L); + case 75: + case 107: + if ((active1 & 0x400L) != 0L) + return jjStartNfaWithStates_1(4, 74, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000L, active5, 0L, active6, 0L, active7, 0x100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 76: + case 108: + if ((active1 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(4, 80, 89); + else if ((active3 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(4, 205, 89); + else if ((active4 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(4, 289, 89); + else if ((active4 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(4, 300, 89); + else if ((active4 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 306; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_1(active0, 0x1800000000000040L, active1, 0L, active2, 0x400020800000800L, active3, 0L, active4, 0x18000000000000L, active5, 0x10000L, active6, 0x30L, active7, 0x100000001000L, active8, 0xe0000000026L, active9, 0x40000c000001000L, active10, 0x1002000000000000L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa5_1(active0, 0x40000000L, active1, 0x1800000L, active2, 0xe00000004000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0x7f00L, active7, 0xc000000000L, active8, 0L, active9, 0x4000000000000000L, active10, 0x20L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x400L) != 0L) + return jjStartNfaWithStates_1(4, 10, 89); + else if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 4; + } + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_1(4, 64, 89); + else if ((active10 & 0x2L) != 0L) + return jjStartNfaWithStates_1(4, 641, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x98000000020L, active1, 0L, active2, 0x400700000L, active3, 0x200000000080L, active4, 0x10L, active5, 0x4000000000000000L, active6, 0L, active7, 0xc00100000000L, active8, 0xf00000000000L, active9, 0x8000000000000200L, active10, 0x2008000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa5_1(active0, 0x20800000080L, active1, 0L, active2, 0x1000000006L, active3, 0x40040000L, active4, 0x10000L, active5, 0x6000000020000c0L, active6, 0x10000000L, active7, 0L, active8, 0L, active9, 0x8000000L, active10, 0x9000000008L, active11, 0L); + case 80: + case 112: + if ((active3 & 0x20000000000L) != 0L) + { + jjmatchedKind = 233; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0xd100000000000000L, active3, 0x1c0000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x800000000L, active8, 0L, active9, 0L, active10, 0x20000800000L, active11, 0L); + case 82: + case 114: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_1(4, 11, 89); + else if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(4, 15, 89); + else if ((active2 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 187, 89); + else if ((active3 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(4, 209, 89); + else if ((active4 & 0x2L) != 0L) + return jjStartNfaWithStates_1(4, 257, 89); + else if ((active4 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 310, 89); + else if ((active5 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(4, 347, 89); + else if ((active5 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 380; + jjmatchedPos = 4; + } + else if ((active6 & 0x2L) != 0L) + return jjStartNfaWithStates_1(4, 385, 89); + else if ((active6 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(4, 421, 89); + else if ((active6 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(4, 429, 89); + else if ((active10 & 0x1L) != 0L) + return jjStartNfaWithStates_1(4, 640, 89); + else if ((active10 & 0x100L) != 0L) + return jjStartNfaWithStates_1(4, 648, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x102010000000L, active1, 0x1800000000000L, active2, 0x3c00c0000L, active3, 0x210000300400100L, active4, 0x8000001c20L, active5, 0xa000500004000000L, active6, 0x680000000000040L, active7, 0x420000000fe800L, active8, 0x1000000000000L, active9, 0L, active10, 0x200L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 114, 89); + else if ((active3 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 242, 89); + else if ((active5 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(4, 341, 89); + else if ((active5 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(4, 343, 89); + else if ((active5 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(4, 362, 89); + else if ((active6 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 437, 89); + else if ((active7 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 511, 89); + else if ((active10 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(4, 685, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x8000000L, active1, 0x1800L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1000000L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x1ff0380000000L, active10, 0x1000040L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(4, 110, 89); + else if ((active3 & 0x4000L) != 0L) + { + jjmatchedKind = 206; + jjmatchedPos = 4; + } + else if ((active3 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(4, 208, 89); + else if ((active3 & 0x8000000000L) != 0L) + { + jjmatchedKind = 231; + jjmatchedPos = 4; + } + else if ((active4 & 0x4L) != 0L) + return jjStartNfaWithStates_1(4, 258, 89); + else if ((active4 & 0x8L) != 0L) + return jjStartNfaWithStates_1(4, 259, 89); + else if ((active4 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 304, 89); + else if ((active6 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(4, 414, 89); + else if ((active7 & 0x100L) != 0L) + return jjStartNfaWithStates_1(4, 456, 89); + else if ((active7 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(4, 469, 89); + else if ((active9 & 0x4L) != 0L) + return jjStartNfaWithStates_1(4, 578, 89); + else if ((active9 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 625, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x201f800000000L, active2, 0x1000180L, active3, 0x8010020008010L, active4, 0x20080100000000L, active5, 0x1800000001800L, active6, 0x2001800080000L, active7, 0x10L, active8, 0x7ffc000000004000L, active9, 0x38000L, active10, 0x80L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa5_1(active0, 0x8000000000000000L, active1, 0L, active2, 0x30000L, active3, 0x180000000000000bL, active4, 0x800000000L, active5, 0x1L, active6, 0x20000004L, active7, 0x2000000L, active8, 0L, active9, 0x2000000000002000L, active10, 0x4000000000004L, active11, 0x20L); + case 86: + case 118: + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0x10000000L, active3, 0L, active4, 0L, active5, 0x2000000000L, active6, 0L, active7, 0L, active8, 0x8000000000000000L, active9, 0x1L, active10, 0x10L, active11, 0L); + case 87: + case 119: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(4, 14, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0x1L); + case 88: + case 120: + if ((active10 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 699, 89); + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(4, 19, 89); + else if ((active0 & 0x200000L) != 0L) + { + jjmatchedKind = 21; + jjmatchedPos = 4; + } + else if ((active2 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 179, 89); + else if ((active2 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(4, 189, 89); + else if ((active11 & 0x80L) != 0L) + return jjStartNfaWithStates_1(4, 711, 89); + return jjMoveStringLiteralDfa5_1(active0, 0x1c10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x400000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc00000000L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_1(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(3, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 5; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa6_1(active0, 0x18001c00000L, active1, 0x1800000001000L, active2, 0x2000000L, active3, 0x40002008000L, active4, 0x3000000000000000L, active5, 0x800000000000L, active6, 0L, active7, 0xe0000000000L, active8, 0L, active9, 0x2000000L, active10, 0x2e0000800400000L, active11, 0L); + case 65: + case 97: + if ((active7 & 0x4000000000L) != 0L) + { + jjmatchedKind = 486; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_1(active0, 0x800000002000L, active1, 0L, active2, 0x100000000004020L, active3, 0xc000000300400000L, active4, 0x8800c20001L, active5, 0x4000002004000000L, active6, 0x1800000000008030L, active7, 0x40008001000000L, active8, 0x8000000000804002L, active9, 0x2800f0000001001L, active10, 0x2000005000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa6_1(active0, 0x600000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x100000000L) != 0L) + { + jjmatchedKind = 32; + jjmatchedPos = 5; + } + else if ((active6 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 432, 89); + else if ((active9 & 0x20L) != 0L) + return jjStartNfaWithStates_1(5, 581, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x7004003f8L, active2, 0L, active3, 0x200L, active4, 0L, active5, 0L, active6, 0x2000000000000000L, active7, 0x280L, active8, 0x300000002000L, active9, 0L, active10, 0x10000000000000L, active11, 0x10L); + case 68: + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 53, 89); + else if ((active3 & 0x80L) != 0L) + return jjStartNfaWithStates_1(5, 199, 89); + else if ((active5 & 0x40L) != 0L) + return jjStartNfaWithStates_1(5, 326, 89); + else if ((active6 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(5, 412, 89); + else if ((active7 & 0x400000000000L) != 0L) + { + jjmatchedKind = 494; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_1(active0, 0x180000000000000L, active1, 0x10000000000000L, active2, 0L, active3, 0x1800000000000003L, active4, 0L, active5, 0L, active6, 0x80c000000000L, active7, 0x800000000000L, active8, 0L, active9, 0x8000000000000000L, active10, 0xf000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(5, 37, 89); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 113, 89); + else if ((active2 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(5, 141, 89); + else if ((active2 & 0x100000L) != 0L) + { + jjmatchedKind = 148; + jjmatchedPos = 5; + } + else if ((active2 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(5, 151, 89); + else if ((active2 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(5, 152, 89); + else if ((active2 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(5, 169, 89); + else if ((active2 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 188, 89); + else if ((active3 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 244, 89); + else if ((active5 & 0x800L) != 0L) + { + jjmatchedKind = 331; + jjmatchedPos = 5; + } + else if ((active5 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(5, 336, 89); + else if ((active7 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(5, 468, 89); + else if ((active8 & 0x4L) != 0L) + return jjStartNfaWithStates_1(5, 514, 89); + else if ((active8 & 0x80L) != 0L) + return jjStartNfaWithStates_1(5, 519, 89); + else if ((active9 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 634, 89); + else if ((active10 & 0x4L) != 0L) + return jjStartNfaWithStates_1(5, 642, 89); + else if ((active10 & 0x80L) != 0L) + return jjStartNfaWithStates_1(5, 647, 89); + return jjMoveStringLiteralDfa6_1(active0, 0x40040000000L, active1, 0L, active2, 0x10600000L, active3, 0x10000000000L, active4, 0xc00000081004200L, active5, 0x1001000L, active6, 0x602000000007f00L, active7, 0L, active8, 0x1000001000000L, active9, 0x3c004000040000L, active10, 0x2000020000000020L, active11, 0L); + case 70: + case 102: + if ((active5 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(5, 361, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe00L, active9, 0x300000000000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active3 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(5, 237, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x200000L, active4, 0L, active5, 0x38L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active4 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(5, 299, 89); + else if ((active7 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(5, 493, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x200000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa6_1(active0, 0x8000000L, active1, 0x20000000800L, active2, 0x10e001c0000180L, active3, 0xc8080020000040L, active4, 0L, active5, 0x2000100000008000L, active6, 0x4000001800000040L, active7, 0x2000000000810L, active8, 0x1c000000070020L, active9, 0x8000008000L, active10, 0x8000000000000L, active11, 0L); + case 76: + case 108: + if ((active3 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(5, 228, 89); + else if ((active6 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(5, 401, 89); + else if ((active7 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(5, 492, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x4L, active2, 0x800030000L, active3, 0L, active4, 0x8000000000000000L, active5, 0xc00002000L, active6, 0x400000000000L, active7, 0x100000000000000L, active8, 0x4480000L, active9, 0x1c00000002000L, active10, 0x1000000000000000L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100L) != 0L) + return jjStartNfaWithStates_1(5, 584, 89); + else if ((active9 & 0x200000L) != 0L) + { + jjmatchedKind = 597; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x2100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x4000000000c00010L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_1(5, 7, 89); + else if ((active1 & 0x800000L) != 0L) + { + jjmatchedKind = 87; + jjmatchedPos = 5; + } + else if ((active2 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(5, 167, 89); + else if ((active3 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(5, 222, 89); + else if ((active5 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 377; + jjmatchedPos = 5; + } + else if ((active7 & 0x2000L) != 0L) + { + jjmatchedKind = 461; + jjmatchedPos = 5; + } + else if ((active10 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(5, 678, 89); + return jjMoveStringLiteralDfa6_1(active0, 0x4040000020000000L, active1, 0xffe0040007000000L, active2, 0x2005000000001L, active3, 0x100L, active4, 0x200000000c0L, active5, 0x400000022000200L, active6, 0x8f040000L, active7, 0x8000043c0fc000L, active8, 0x1fff8000000L, active9, 0x2000001000000000L, active10, 0x400000000a000000L, active11, 0x8L); + case 79: + case 111: + return jjMoveStringLiteralDfa6_1(active0, 0x1800000000000000L, active1, 0L, active2, 0x400000800L, active3, 0L, active4, 0x20000006000000L, active5, 0L, active6, 0x400000000L, active7, 0x1801000880000000L, active8, 0xe0002100000L, active9, 0xc00000000L, active10, 0x30800010L, active11, 0x1L); + case 80: + case 112: + if ((active7 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(5, 473, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000000000L, active10, 0x404000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x2L) != 0L) + { + jjmatchedKind = 129; + jjmatchedPos = 5; + } + else if ((active3 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(5, 204, 89); + else if ((active5 & 0x2L) != 0L) + return jjStartNfaWithStates_1(5, 321, 89); + else if ((active5 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(5, 363, 89); + else if ((active7 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(5, 484, 89); + else if ((active7 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 505; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_1(active0, 0x8000000800000000L, active1, 0x9f800000000L, active2, 0x800000000c8004L, active3, 0x400000000000L, active4, 0xa00000000000L, active5, 0x400000000001L, active6, 0x8000160000400000L, active7, 0x400000000000400L, active8, 0x8000L, active9, 0x8030000L, active10, 0x100000000000000L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(5, 16, 89); + else if ((active2 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 186, 89); + else if ((active3 & 0x10L) != 0L) + return jjStartNfaWithStates_1(5, 196, 89); + else if ((active3 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(5, 236, 89); + else if ((active5 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(5, 338, 89); + else if ((active5 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 368, 89); + else if ((active5 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 383, 89); + else if ((active10 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(5, 661, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x200000008000L, active2, 0L, active3, 0x1000000L, active4, 0xc10L, active5, 0x100180L, active6, 0x80010000000000L, active7, 0x2fL, active8, 0x7fe0000000000000L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_1(5, 5, 89); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(5, 43, 89); + else if ((active1 & 0x8000000L) != 0L) + { + jjmatchedKind = 91; + jjmatchedPos = 5; + } + else if ((active2 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 190; + jjmatchedPos = 5; + } + else if ((active3 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(5, 212, 89); + else if ((active3 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 249, 89); + else if ((active4 & 0x20L) != 0L) + return jjStartNfaWithStates_1(5, 261, 89); + else if ((active5 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(5, 365, 89); + else if ((active5 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 370, 89); + else if ((active6 & 0x4L) != 0L) + return jjStartNfaWithStates_1(5, 386, 89); + else if ((active7 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(5, 460, 89); + else if ((active7 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(5, 499, 89); + else if ((active9 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(5, 590, 89); + else if ((active10 & 0x40L) != 0L) + return jjStartNfaWithStates_1(5, 646, 89); + else if ((active10 & 0x200L) != 0L) + return jjStartNfaWithStates_1(5, 649, 89); + return jjMoveStringLiteralDfa6_1(active0, 0x2000010000000L, active1, 0xf03e0000L, active2, 0x8000002000000000L, active3, 0x400000008L, active4, 0x18000000040000L, active5, 0L, active6, 0x20010000L, active7, 0x20000000000040L, active8, 0L, active9, 0x380100400L, active10, 0L, active11, 0x20L); + case 85: + case 117: + return jjMoveStringLiteralDfa6_1(active0, 0x20000000040L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0x400000000000L, active9, 0L, active10, 0x8000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010001000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0xc0L, active10, 0x200000000L, active11, 0L); + case 87: + case 119: + if ((active4 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(5, 272, 89); + else if ((active10 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(5, 676, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x40000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(5, 44, 89); + return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_1(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa6_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(4, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 6; + } + switch(curChar) + { + case 50: + if ((active6 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 447, 89); + break; + case 95: + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0xc002c0L, active10, 0x2000000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa7_1(active0, 0x40000000400000L, active1, 0xf800000000L, active2, 0x80000000040000L, active3, 0xc0000000000100L, active4, 0x4010001000L, active5, 0x2000000L, active6, 0L, active7, 0x40L, active8, 0x3800000200000L, active9, 0x1c0038c000000L, active10, 0x2000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0x40000000L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x800000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x200000000000L) != 0L) + { + jjmatchedKind = 173; + jjmatchedPos = 6; + } + else if ((active5 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(6, 364, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x800000L, active1, 0x8000L, active2, 0xc06000000800L, active3, 0x440000000000L, active4, 0x40L, active5, 0x1000000L, active6, 0L, active7, 0x80020001000800L, active8, 0x1000000L, active9, 0xf0000000000L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active2 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(6, 149, 89); + else if ((active2 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(6, 156, 89); + else if ((active3 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(6, 232, 89); + else if ((active4 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 314, 89); + else if ((active10 & 0x20L) != 0L) + return jjStartNfaWithStates_1(6, 645, 89); + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x6000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x40L, active7, 0L, active8, 0L, active9, 0x2000000000040000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 6; + } + else if ((active1 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(6, 81, 89); + else if ((active2 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(6, 143, 89); + else if ((active3 & 0x1L) != 0L) + return jjStartNfaWithStates_1(6, 192, 89); + else if ((active3 & 0x8L) != 0L) + return jjStartNfaWithStates_1(6, 195, 89); + else if ((active3 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 251, 89); + else if ((active6 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(6, 413, 89); + else if ((active6 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(6, 425, 89); + else if ((active7 & 0x20L) != 0L) + return jjStartNfaWithStates_1(6, 453, 89); + else if ((active7 & 0x80L) != 0L) + return jjStartNfaWithStates_1(6, 455, 89); + else if ((active7 & 0x4000000L) != 0L) + { + jjmatchedKind = 474; + jjmatchedPos = 6; + } + else if ((active9 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 636, 89); + else if ((active11 & 0x10L) != 0L) + return jjStartNfaWithStates_1(6, 708, 89); + else if ((active11 & 0x20L) != 0L) + return jjStartNfaWithStates_1(6, 709, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x100000000000000L, active1, 0x4L, active2, 0x40000000080000L, active3, 0x2100000001000000L, active4, 0x800000000c00L, active5, 0x4000001081b9L, active6, 0x404000000000L, active7, 0x3803c000L, active8, 0x2000L, active9, 0x10L, active10, 0x110000020000f000L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa7_1(active0, 0x8000000000L, active1, 0x800L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 59; + jjmatchedPos = 6; + } + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 62, 89); + else if ((active4 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(6, 297, 89); + else if ((active5 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(6, 349, 89); + else if ((active6 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(6, 402, 89); + else if ((active6 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(6, 415, 89); + else if ((active7 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(6, 482, 89); + else if ((active10 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(6, 667, 89); + else if ((active10 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 702, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x1000000000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 49, 89); + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x100000000000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa7_1(active0, 0x810000000L, active1, 0x100000e03c0000L, active2, 0x8000000200000000L, active3, 0x1000000000040002L, active4, 0x18000000040010L, active5, 0xc00000000L, active6, 0x80018000010000L, active7, 0x120000800040000L, active8, 0x7fe0000000000e00L, active9, 0xc000000000030000L, active10, 0x8010000000000000L, active11, 0L); + case 76: + case 108: + if ((active2 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(6, 142, 89); + else if ((active3 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(6, 224, 89); + else if ((active3 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 255; + jjmatchedPos = 6; + } + else if ((active4 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(6, 295, 89); + else if ((active5 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(6, 346, 89); + else if ((active6 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(6, 399, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x20000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1L, active5, 0x4000812000000000L, active6, 0L, active7, 0x1L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa7_1(active0, 0x21000000L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0xc400000000000L, active9, 0L, active10, 0x1000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(6, 42, 89); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(6, 47, 89); + else if ((active3 & 0x40L) != 0L) + return jjStartNfaWithStates_1(6, 198, 89); + else if ((active3 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(6, 213, 89); + else if ((active3 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(6, 214, 89); + else if ((active6 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(6, 406, 89); + else if ((active6 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(6, 418, 89); + else if ((active7 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 496, 89); + else if ((active7 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 507; + jjmatchedPos = 6; + } + else if ((active10 & 0x8L) != 0L) + return jjStartNfaWithStates_1(6, 643, 89); + else if ((active10 & 0x10000000L) != 0L) + { + jjmatchedKind = 668; + jjmatchedPos = 6; + } + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x20000000000L, active2, 0x10001000000000L, active3, 0x80000000000L, active4, 0x1000000000000000L, active5, 0x2000000000000200L, active6, 0x4600000000000000L, active7, 0x1000040000000000L, active8, 0x100e0000028020L, active9, 0x8c02000000L, active10, 0x80000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x1000L, active2, 0x800000000L, active3, 0x20000000L, active4, 0L, active5, 0L, active6, 0x2000001800000000L, active7, 0L, active8, 0x4580000L, active9, 0x300000000000L, active10, 0x400000L, active11, 0L); + case 80: + case 112: + if ((active10 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(6, 663, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x10000000000L, active1, 0xa00000000000L, active2, 0x180000000L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0x10L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(6, 150, 89); + else if ((active4 & 0x200L) != 0L) + return jjStartNfaWithStates_1(6, 265, 89); + else if ((active4 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(6, 270, 89); + else if ((active4 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(6, 273, 89); + else if ((active4 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 309, 89); + else if ((active6 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 433, 89); + else if ((active8 & 0x2L) != 0L) + return jjStartNfaWithStates_1(6, 513, 89); + else if ((active9 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 626; + jjmatchedPos = 6; + } + else if ((active10 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(6, 666, 89); + else if ((active10 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(6, 681, 89); + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0x100000002000000L, active3, 0x402000000L, active4, 0x2000000000c00000L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x8000000000000000L, active9, 0xb8000000100001L, active10, 0L, active11, 0x1L); + case 83: + case 115: + if ((active4 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 315, 89); + else if ((active5 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(6, 332, 89); + else if ((active5 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 378, 89); + else if ((active7 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(6, 467, 89); + else if ((active7 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(6, 495, 89); + else if ((active10 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 690, 89); + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x1000000000000L, active2, 0x400000020L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0L, active9, 0x1000L, active10, 0x20000000000000L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(6, 86, 89); + else if ((active1 & 0x100000000L) != 0L) + { + jjmatchedKind = 96; + jjmatchedPos = 6; + } + else if ((active1 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(6, 107, 89); + else if ((active1 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 117; + jjmatchedPos = 6; + } + else if ((active2 & 0x10000L) != 0L) + { + jjmatchedKind = 144; + jjmatchedPos = 6; + } + else if ((active2 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 177, 89); + else if ((active3 & 0x200L) != 0L) + return jjStartNfaWithStates_1(6, 201, 89); + else if ((active6 & 0x1000000L) != 0L) + { + jjmatchedKind = 408; + jjmatchedPos = 6; + } + else if ((active7 & 0x200L) != 0L) + return jjStartNfaWithStates_1(6, 457, 89); + else if ((active7 & 0x400L) != 0L) + return jjStartNfaWithStates_1(6, 458, 89); + else if ((active8 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(6, 530, 89); + else if ((active9 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(6, 612, 89); + else if ((active10 & 0x10L) != 0L) + return jjStartNfaWithStates_1(6, 644, 89); + else if ((active10 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(6, 679, 89); + return jjMoveStringLiteralDfa7_1(active0, 0x48002040L, active1, 0xffc00006100003f8L, active2, 0x20001L, active3, 0x4008000200000000L, active4, 0x80L, active5, 0L, active6, 0xe007f00L, active7, 0x42000000000000L, active8, 0x1fff8804000L, active9, 0x20000000000a000L, active10, 0x60a000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa7_1(active0, 0x600000000L, active1, 0x50000000000L, active2, 0L, active3, 0L, active4, 0x8000000008000000L, active5, 0x2000L, active6, 0x800000000000L, active7, 0x80000000L, active8, 0x2000000L, active9, 0x400L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0x1800040000000000L, active7, 0x10L, active8, 0L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x6L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(6, 63, 89); + else if ((active4 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(6, 301, 89); + else if ((active6 & 0x20L) != 0L) + return jjStartNfaWithStates_1(6, 389, 89); + else if ((active6 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(6, 428, 89); + return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_1(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa7_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(5, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 7; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa8_1(active0, 0x1000000000000000L, active1, 0xffc0000006000000L, active2, 0xc00000000001L, active3, 0L, active4, 0L, active5, 0x38L, active6, 0x8000000L, active7, 0x1000000038000000L, active8, 0x7fe0000000000000L, active9, 0x38000000000000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa8_1(active0, 0x10001000000L, active1, 0x1000000000000L, active2, 0x2000800L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x60000000000L, active8, 0x100004020000L, active9, 0x2000200L, active10, 0x80000000000000L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(7, 531, 89); + else if ((active8 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(7, 534, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000040L, active8, 0x8000000002000000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 182, 91); + else if ((active8 & 0x200L) != 0L) + { + jjmatchedKind = 521; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0x10000000000L, active2, 0L, active3, 0x1000000L, active4, 0xc00L, active5, 0x180L, active6, 0x600000000000000L, active7, 0x80000000000L, active8, 0xc00L, active9, 0x1L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 56, 89); + else if ((active2 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(7, 147, 89); + else if ((active11 & 0x1L) != 0L) + return jjStartNfaWithStates_1(7, 704, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x40L) != 0L) + return jjStartNfaWithStates_1(7, 6, 89); + else if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(7, 13, 89); + else if ((active1 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(7, 79, 89); + else if ((active1 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(7, 106, 89); + else if ((active2 & 0x20L) != 0L) + return jjStartNfaWithStates_1(7, 133, 89); + else if ((active2 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(7, 158, 89); + else if ((active4 & 0x40L) != 0L) + return jjStartNfaWithStates_1(7, 262, 89); + else if ((active4 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(7, 288, 89); + else if ((active4 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(7, 291, 89); + else if ((active4 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 319, 89); + else if ((active5 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(7, 333, 89); + else if ((active5 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(7, 360, 89); + else if ((active6 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(7, 426, 89); + else if ((active7 & 0x10L) != 0L) + return jjStartNfaWithStates_1(7, 452, 89); + else if ((active7 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 503, 89); + else if ((active8 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(7, 526, 89); + else if ((active8 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(7, 535, 89); + else if ((active8 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 562; + jjmatchedPos = 7; + } + else if ((active9 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 633, 89); + else if ((active10 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 689, 89); + return jjMoveStringLiteralDfa8_1(active0, 0x20000000L, active1, 0x100003f8L, active2, 0x1000000180L, active3, 0x200000000L, active4, 0x2000000008000000L, active5, 0x800000000000L, active6, 0x7f00L, active7, 0L, active8, 0x841fff8000000L, active9, 0x2000004c00000000L, active10, 0x400000000000000L, active11, 0L); + case 70: + case 102: + if ((active10 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(7, 662, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L, active11, 0L); + case 71: + case 103: + if ((active2 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 180, 89); + else if ((active3 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(7, 235, 89); + else if ((active5 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 381, 89); + else if ((active9 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(7, 615, 89); + return jjMoveStringLiteralDfa8_1(active0, 0x400000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000000L, active5, 0L, active6, 0x1800400000000000L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0x100000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(7, 165, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x400000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa8_1(active0, 0x8000000L, active1, 0xfe00000800L, active2, 0L, active3, 0L, active4, 0x1000080L, active5, 0x4000000000000200L, active6, 0x6000040L, active7, 0L, active8, 0x1018000L, active9, 0x102000L, active10, 0x20000000L, active11, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active7 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(7, 472, 89); + break; + case 76: + case 108: + if ((active3 & 0x100L) != 0L) + return jjStartNfaWithStates_1(7, 200, 89); + else if ((active4 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(7, 268, 89); + else if ((active5 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(7, 345, 89); + else if ((active8 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 560, 89); + else if ((active10 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 700, 89); + return jjMoveStringLiteralDfa8_1(active0, 0x40020000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010000001L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000100000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0x18000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x384000000L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active3 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(7, 221, 89); + else if ((active6 & 0x800000000L) != 0L) + { + jjmatchedKind = 419; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0x1000004L, active2, 0x200000004L, active3, 0x3100000000040002L, active4, 0L, active5, 0x400000000000L, active6, 0x9000000000L, active7, 0x400008880040000L, active8, 0L, active9, 0x30010L, active10, 0x8000000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa8_1(active0, 0x10800000L, active1, 0xa000e03c0000L, active2, 0x8000000000000000L, active3, 0x4000040002000000L, active4, 0x40000L, active5, 0x1000000L, active6, 0x10000090000L, active7, 0x40000000000001L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0x8L); + case 80: + case 112: + if ((active10 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(7, 664, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0x40L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active8 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(7, 533, 89); + else if ((active10 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(7, 673, 89); + return jjMoveStringLiteralDfa8_1(active0, 0x8040000000L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0xc00000L, active5, 0L, active6, 0x800000000000L, active7, 0L, active8, 0x800000000000L, active9, 0x80300008000400L, active10, 0x40000002000000L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(7, 105, 89); + else if ((active2 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(7, 145, 89); + else if ((active5 & 0x1L) != 0L) + return jjStartNfaWithStates_1(7, 320, 89); + else if ((active5 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(7, 335, 89); + else if ((active6 & 0x10L) != 0L) + return jjStartNfaWithStates_1(7, 388, 89); + else if ((active6 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(7, 422, 89); + else if ((active9 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(7, 594, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0x10000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1080L, active10, 0x2000000000000000L, active11, 0L); + case 84: + case 116: + if ((active2 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(7, 166, 89); + else if ((active5 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(7, 340, 89); + else if ((active7 & 0x800L) != 0L) + return jjStartNfaWithStates_1(7, 459, 89); + else if ((active8 & 0x20L) != 0L) + return jjStartNfaWithStates_1(7, 517, 89); + return jjMoveStringLiteralDfa8_1(active0, 0x600000000L, active1, 0L, active2, 0x100000580000000L, active3, 0xc0000000000000L, active4, 0x10L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0xc001cf0000400000L, active10, 0x10000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0x2000000000L, active6, 0x2000000000000000L, active7, 0L, active8, 0L, active9, 0x808000L, active10, 0x800000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000000000000L, active7, 0x20000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active2 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(7, 163, 89); + break; + case 88: + case 120: + if ((active7 & 0x2L) != 0L) + return jjStartNfaWithStates_1(7, 449, 89); + break; + case 89: + case 121: + if ((active3 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(7, 226, 89); + else if ((active3 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 243, 89); + else if ((active7 & 0x4L) != 0L) + return jjStartNfaWithStates_1(7, 450, 89); + else if ((active7 & 0x8L) != 0L) + return jjStartNfaWithStates_1(7, 451, 89); + else if ((active7 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(7, 497, 89); + return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000000000000L, active9, 0L, active10, 0x228000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa8_1(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0xc00000000L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_1(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa8_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(6, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000000000L, active7, 0x3c000L, active8, 0x400L, active9, 0xc00001000L, active10, 0x8000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa9_1(active0, 0x8800000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0xc00080L, active5, 0L, active6, 0L, active7, 0x500008000000000L, active8, 0L, active9, 0x80000000000080L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(8, 557, 89); + break; + case 67: + case 99: + if ((active9 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(8, 596, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x40000000000000L, active2, 0x1000000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0x400000000000L, active6, 0L, active7, 0x8000000L, active8, 0x800000000000L, active9, 0x8000000000000L, active10, 0x800000000L, active11, 0L); + case 68: + case 100: + if ((active1 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(8, 92, 89); + else if ((active3 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(8, 225, 89); + else if ((active9 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 637, 89); + else if ((active10 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 698, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x180000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000L) != 0L) + { + jjmatchedKind = 33; + jjmatchedPos = 8; + } + else if ((active2 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 183, 89); + else if ((active3 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 246; + jjmatchedPos = 8; + } + else if ((active4 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 307; + jjmatchedPos = 8; + } + else if ((active5 & 0x400000000L) != 0L) + { + jjmatchedKind = 354; + jjmatchedPos = 8; + } + else if ((active5 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(8, 357, 89); + else if ((active6 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(8, 431, 89); + else if ((active6 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 439, 89); + else if ((active7 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 501, 89); + else if ((active9 & 0x400L) != 0L) + return jjStartNfaWithStates_1(8, 586, 89); + else if ((active9 & 0x400000000000L) != 0L) + { + jjmatchedKind = 622; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_1(active0, 0x400000000L, active1, 0x800L, active2, 0L, active3, 0x80000000000000L, active4, 0x10800086000000L, active5, 0x800000000L, active6, 0x4200400000000000L, active7, 0x100000000L, active8, 0x100000L, active9, 0x800000000000L, active10, 0L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(8, 22, 89); + else if ((active3 & 0x2L) != 0L) + return jjStartNfaWithStates_1(8, 193, 89); + else if ((active3 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(8, 210, 89); + else if ((active3 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 252, 89); + else if ((active6 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(8, 423, 89); + else if ((active7 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(8, 466, 89); + else if ((active9 & 0x10000L) != 0L) + { + jjmatchedKind = 592; + jjmatchedPos = 8; + } + else if ((active10 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 703, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x4L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000L, active9, 0x20200L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0x80000000000000L, active9, 0x1L, active10, 0L, active11, 0L); + case 73: + case 105: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(8, 41, 89); + return jjMoveStringLiteralDfa9_1(active0, 0x40000040000000L, active1, 0x1000L, active2, 0x100000680000000L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000000L, active9, 0x80010f0000400000L, active10, 0x210000000000f000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0x8000L, active4, 0L, active5, 0x8L, active6, 0x6000000L, active7, 0x40L, active8, 0x2000002000000L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100000000000L) != 0L) + { + jjmatchedKind = 620; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x1000000000000L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0L, active7, 0x40000000000L, active8, 0x700000001000000L, active9, 0x200002000000L, active10, 0x80000000000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(8, 28, 89); + else if ((active1 & 0x40000L) != 0L) + { + jjmatchedKind = 82; + jjmatchedPos = 8; + } + else if ((active1 & 0x20000000L) != 0L) + { + jjmatchedKind = 93; + jjmatchedPos = 8; + } + else if ((active2 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 191, 89); + else if ((active4 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(8, 274, 89); + else if ((active6 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(8, 400, 89); + else if ((active6 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(8, 424, 89); + return jjMoveStringLiteralDfa9_1(active0, 0x1000000020800000L, active1, 0x20f8c0380000L, active2, 0x2000000L, active3, 0x40000000000L, active4, 0L, active5, 0x800001000000L, active6, 0x2000000000000040L, active7, 0x10000000L, active8, 0x18000L, active9, 0x10000000000000L, active10, 0x20000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x600000000L, active2, 0x100000000L, active3, 0x1000000L, active4, 0L, active5, 0x190L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40L, active10, 0x40000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(8, 111, 89); + else if ((active9 & 0x80000000L) != 0L) + { + jjmatchedKind = 607; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x200000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1L, active8, 0L, active9, 0x304000000L, active10, 0x200000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 8; + } + else if ((active3 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 254, 89); + else if ((active6 & 0x100L) != 0L) + { + jjmatchedKind = 392; + jjmatchedPos = 8; + } + else if ((active7 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 502, 89); + else if ((active8 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_1(8, 556, 89); + return jjMoveStringLiteralDfa9_1(active0, 0x10000000000L, active1, 0xc000000000003f0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0x8007e00L, active7, 0L, active8, 0x41fff0020000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0x1008000000000000L, active9, 0x20000000802000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 116, 89); + else if ((active3 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 253, 89); + else if ((active4 & 0x400L) != 0L) + { + jjmatchedKind = 266; + jjmatchedPos = 8; + } + else if ((active7 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(8, 479, 89); + else if ((active7 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(8, 483, 89); + else if ((active8 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(8, 538, 89); + else if ((active9 & 0x10L) != 0L) + return jjStartNfaWithStates_1(8, 580, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0xe000010000000000L, active2, 0x800L, active3, 0x100000000000000L, active4, 0x800L, active5, 0x4000000000000020L, active6, 0L, active7, 0x20000000000L, active8, 0x2800L, active9, 0x4000000000008000L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x4010000000L, active5, 0x200L, active6, 0x80000L, active7, 0x1000000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa9_1(active0, 0x8000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active3 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(8, 217, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active6 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 443, 89); + return jjMoveStringLiteralDfa9_1(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active3 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(8, 238, 89); + else if ((active4 & 0x1L) != 0L) + return jjStartNfaWithStates_1(8, 256, 89); + else if ((active6 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 444, 89); + else if ((active9 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(8, 603, 89); + else if ((active10 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(8, 665, 89); + else if ((active10 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(8, 692, 89); + return jjMoveStringLiteralDfa9_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4000000000000000L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_1(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa9_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(7, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 9; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa10_1(active0, 0x1000000L, active1, 0x803800f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7e00L, active7, 0L, active8, 0L, active9, 0x804000020000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa10_1(active0, 0x1000000000000000L, active1, 0x2c0000040000000L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x8000000L, active7, 0x20018000000L, active8, 0x200e0001100000L, active9, 0x18000100000001L, active10, 0L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000080L, active5, 0L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(9, 30, 89); + return jjMoveStringLiteralDfa10_1(active0, 0x800000L, active1, 0x1000000000000000L, active2, 0x400000000L, active3, 0x40000000000L, active4, 0x6000000L, active5, 0x10L, active6, 0L, active7, 0x20004000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L, active11, 0L); + case 68: + case 100: + if ((active5 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(9, 344, 89); + else if ((active5 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(9, 355, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x200000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(9, 27, 89); + else if ((active2 & 0x800L) != 0L) + return jjStartNfaWithStates_1(9, 139, 89); + else if ((active2 & 0x40000L) != 0L) + return jjStartNfaWithStates_1(9, 146, 89); + else if ((active4 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(9, 284, 89); + else if ((active4 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(9, 294, 89); + else if ((active7 & 0x1L) != 0L) + return jjStartNfaWithStates_1(9, 448, 89); + else if ((active7 & 0x40L) != 0L) + return jjStartNfaWithStates_1(9, 454, 89); + else if ((active7 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(9, 490, 89); + else if ((active8 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(9, 537, 89); + else if ((active9 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(9, 591, 89); + else if ((active9 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(9, 601, 89); + else if ((active10 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 695, 89); + else if ((active10 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 697, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000028L, active6, 0x6000000L, active7, 0x80000000000L, active8, 0x7000000008000000L, active9, 0x4000000000802000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active6 & 0x40L) != 0L) + return jjStartNfaWithStates_1(9, 390, 89); + else if ((active8 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(9, 527, 89); + else if ((active9 & 0x200L) != 0L) + return jjStartNfaWithStates_1(9, 585, 89); + else if ((active10 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(9, 669, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x800000000000L, active6, 0x80000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0x400000000L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x6000000000000100L, active2, 0x180L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0L, active7, 0L, active8, 0x302400000002000L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active2 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(9, 153, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000800000000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x80000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active5 & 0x200L) != 0L) + return jjStartNfaWithStates_1(9, 329, 89); + return jjMoveStringLiteralDfa10_1(active0, 0x8000000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0x800400080L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active1 & 0x200000000L) != 0L) + { + jjmatchedKind = 97; + jjmatchedPos = 9; + } + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x400000000L, active2, 0L, active3, 0x1000000L, active4, 0L, active5, 0x180L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000400L, active9, 0L, active10, 0xf000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0xc00010000000000L, active2, 0x80000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x480000000000000L, active9, 0x80010f0000001000L, active10, 0x100000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 112, 89); + else if ((active9 & 0x40L) != 0L) + return jjStartNfaWithStates_1(9, 582, 89); + break; + case 82: + case 114: + if ((active1 & 0x800L) != 0L) + return jjStartNfaWithStates_1(9, 75, 89); + else if ((active2 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(9, 160, 89); + else if ((active4 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(9, 287, 89); + else if ((active7 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(9, 480, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000001000000000L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(9, 34, 89); + else if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_1(9, 73, 89); + else if ((active6 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(9, 430, 89); + else if ((active6 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 441, 89); + else if ((active9 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(9, 621, 89); + else if ((active11 & 0x8L) != 0L) + return jjStartNfaWithStates_1(9, 707, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0x200000001L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0L, active7, 0x1000000000020000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(9, 29, 89); + else if ((active1 & 0x800000000L) != 0L) + { + jjmatchedKind = 99; + jjmatchedPos = 9; + } + else if ((active2 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(9, 164, 89); + else if ((active6 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 445, 89); + else if ((active8 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(9, 528, 89); + return jjMoveStringLiteralDfa10_1(active0, 0x40010800000000L, active1, 0xf000000004L, active2, 0x100000000000000L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1fff0000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active4 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(9, 303, 89); + break; + case 89: + case 121: + if ((active4 & 0x400000L) != 0L) + { + jjmatchedKind = 278; + jjmatchedPos = 9; + } + else if ((active4 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(9, 283, 89); + else if ((active5 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 382, 89); + else if ((active8 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(9, 529, 89); + else if ((active9 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(9, 631, 89); + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa10_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000000000000000L, active11, 0L); + default : + break; + } + return jjStartNfa_1(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa10_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_1(8, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 10; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x7400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x6000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa11_1(active0, 0x800000L, active1, 0x8000000000000000L, active2, 0L, active3, 0x40000000000L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0xc84881fff0000400L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active8 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(10, 558, 89); + return jjMoveStringLiteralDfa11_1(active0, 0x1000000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0x10000L, active8, 0x1100000000000000L, active9, 0x4000000000L, active10, 0L); + case 68: + case 100: + if ((active3 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(10, 216, 89); + else if ((active5 & 0x80L) != 0L) + return jjStartNfaWithStates_1(10, 327, 89); + else if ((active5 & 0x100L) != 0L) + return jjStartNfaWithStates_1(10, 328, 89); + else if ((active9 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 638, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x100000000L, active10, 0L); + case 69: + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(10, 39, 89); + else if ((active1 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(10, 88, 89); + else if ((active2 & 0x4L) != 0L) + return jjStartNfaWithStates_1(10, 130, 89); + else if ((active3 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(10, 207, 89); + else if ((active4 & 0x10L) != 0L) + return jjStartNfaWithStates_1(10, 260, 89); + else if ((active7 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(10, 487, 89); + else if ((active7 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 506, 89); + else if ((active9 & 0x400000L) != 0L) + return jjStartNfaWithStates_1(10, 598, 89); + else if ((active9 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(10, 602, 89); + else if ((active10 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 701, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0x1000000000L, active7, 0x1000000000008000L, active8, 0x2000000000000000L, active9, 0L, active10, 0x800080000f000L); + case 70: + case 102: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active6 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 442, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_1(10, 66, 89); + else if ((active6 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(10, 403, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L); + case 73: + case 105: + return jjMoveStringLiteralDfa11_1(active0, 0x10800000000L, active1, 0x200000001000L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xa00000000L, active10, 0L); + case 76: + case 108: + if ((active1 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(10, 94, 89); + else if ((active8 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(10, 536, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x400000000000010L, active2, 0L, active3, 0L, active4, 0x80L, active5, 0L, active6, 0L, active7, 0x100020000000000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa11_1(active0, 0x1000000000000000L, active1, 0x6000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x80010000000L, active8, 0L, active9, 0x10000000000000L, active10, 0L); + case 78: + case 110: + if ((active2 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(10, 159, 89); + else if ((active8 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(10, 532, 89); + else if ((active9 & 0x10000000000L) != 0L) + { + jjmatchedKind = 616; + jjmatchedPos = 10; + } + else if ((active9 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 624, 89); + else if ((active10 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 696, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x86100000L, active2, 0xc00000000180L, active3, 0L, active4, 0L, active5, 0x8L, active6, 0x8000400L, active7, 0L, active8, 0x602000000000000L, active9, 0x80000e0000000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x2000L, active9, 0x400000000L, active10, 0L); + case 80: + case 112: + if ((active9 & 0x80L) != 0L) + return jjStartNfaWithStates_1(10, 583, 89); + else if ((active10 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 694, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active1 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(10, 104, 89); + else if ((active8 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(10, 539, 89); + else if ((active9 & 0x1L) != 0L) + return jjStartNfaWithStates_1(10, 576, 89); + else if ((active9 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(10, 599, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0x800000021000L, active10, 0L); + case 83: + case 115: + if ((active1 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_1(10, 103, 89); + else if ((active2 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(10, 162, 89); + else if ((active4 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(10, 280, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x2001e0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active4 & 0x2000000L) != 0L) + { + jjmatchedKind = 281; + jjmatchedPos = 10; + } + else if ((active8 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 564, 89); + else if ((active9 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(10, 589, 89); + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0x2c0000000000000L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0x10000004000000L, active5, 0x800000000010L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000000L, active9, 0L, active10, 0L); + case 87: + case 119: + if ((active1 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 123, 89); + break; + case 88: + case 120: + return jjMoveStringLiteralDfa11_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x20L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 54, 89); + else if ((active3 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 247, 89); + else if ((active8 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(10, 565, 89); + break; + default : + break; + } + return jjStartNfa_1(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa11_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(9, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 11; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active7 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(11, 491, 89); + return jjMoveStringLiteralDfa12_1(active0, 0x1000000L, active1, 0x140000000180000L, active2, 0L, active3, 0L, active4, 0x10000004000000L, active5, 0L, active6, 0x400L, active7, 0x8000000L, active8, 0L, active9, 0x8008000000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0x1006200000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x40040000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x100000000L) != 0L) + return jjStartNfaWithStates_1(11, 608, 89); + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 69: + case 101: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 60, 89); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 119, 89); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 122, 89); + else if ((active1 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 125; + jjmatchedPos = 11; + } + else if ((active4 & 0x80L) != 0L) + return jjStartNfaWithStates_1(11, 263, 89); + else if ((active7 & 0x10000000L) != 0L) + return jjStartNfaWithStates_1(11, 476, 89); + else if ((active7 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 504, 89); + else if ((active8 & 0x800L) != 0L) + return jjStartNfaWithStates_1(11, 523, 89); + else if ((active9 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 628, 89); + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0x50000000000000f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0x4000000000000000L, active7, 0x20000000L, active8, 0L, active9, 0x20800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0x8L, active6, 0x1000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 121, 89); + else if ((active5 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(11, 367, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000L, active10, 0L); + case 75: + case 107: + if ((active6 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(11, 411, 89); + else if ((active8 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 573, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0x1fff0000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000400L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(11, 76, 89); + else if ((active4 & 0x800L) != 0L) + return jjStartNfaWithStates_1(11, 267, 89); + else if ((active8 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(11, 525, 89); + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0x8000202400000000L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0x80000000000L, active9, 0x800000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa12_1(active0, 0x800000000L, active1, 0L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x20000000000L, active8, 0x1000000000000000L, active9, 0x4000000000L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active2 & 0x1L) != 0L) + return jjStartNfaWithStates_1(11, 128, 89); + else if ((active4 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 316, 89); + else if ((active7 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 508, 89); + else if ((active8 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(11, 559, 89); + else if ((active8 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 567, 89); + else if ((active8 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 574, 89); + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x8900000000000000L, active9, 0L, active10, 0x20000000000000L); + case 83: + case 115: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe0000000000L, active10, 0L); + case 84: + case 116: + if ((active3 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(11, 234, 89); + else if ((active5 & 0x20L) != 0L) + return jjStartNfaWithStates_1(11, 325, 89); + else if ((active8 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 561, 89); + else if ((active10 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(11, 675, 89); + return jjMoveStringLiteralDfa12_1(active0, 0x10000800000L, active1, 0x100L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x400000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa12_1(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x200000000000000L, active9, 0x400000000L, active10, 0L); + case 89: + case 121: + if ((active10 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(11, 691, 89); + break; + default : + break; + } + return jjStartNfa_1(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa12_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(10, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 12; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa13_1(active0, 0x800000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4001fff0000000L, active9, 0xe0000000000L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x3400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active2 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(12, 161, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0xa00L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x400L) != 0L) + return jjStartNfaWithStates_1(12, 522, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000007000L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + if ((active9 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(12, 609, 89); + break; + case 71: + case 103: + if ((active1 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_1(12, 109, 89); + else if ((active4 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(12, 279, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000000L, active5, 0L, active6, 0L, active7, 0x20000008000L, active8, 0L, active9, 0x800000021000L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_1(12, 570, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa13_1(active0, 0x10000000000L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 76: + case 108: + if ((active9 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(12, 639, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x1000000080100000L, active2, 0L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0x400L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(12, 35, 89); + else if ((active2 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(12, 184, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x100000000000000L, active9, 0L, active10, 0x20000000000000L); + case 80: + case 112: + if ((active8 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(12, 563, 89); + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active9 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(12, 610, 89); + return jjMoveStringLiteralDfa13_1(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0xc000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x60800e0L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0x18L, active6, 0L, active7, 0L, active8, 0xa00000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa13_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x4800000000L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(12, 575, 89); + break; + default : + break; + } + return jjStartNfa_1(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa13_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(11, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 13; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0xe0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 124, 89); + else if ((active7 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(13, 477, 89); + else if ((active9 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 629, 89); + return jjMoveStringLiteralDfa14_1(active0, 0x800000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0x20000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 572, 89); + return jjMoveStringLiteralDfa14_1(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xf0000000L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x100000L) != 0L) + return jjStartNfaWithStates_1(13, 84, 89); + else if ((active6 & 0x200L) != 0L) + return jjStartNfaWithStates_1(13, 393, 89); + else if ((active6 & 0x400L) != 0L) + return jjStartNfaWithStates_1(13, 394, 89); + else if ((active8 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 569, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0x800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active4 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(13, 282, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x8L) != 0L) + return jjStartNfaWithStates_1(13, 323, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80700000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x1000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x2400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active3 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 248, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x20000000000L, active9, 0x4000000000L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa14_1(active0, 0x10000000000L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 80: + case 112: + if ((active4 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 308, 89); + break; + case 82: + case 114: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 83: + case 115: + if ((active7 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(13, 489, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(13, 446, 89); + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x38000L, active8, 0L, active9, 0x800000000L, active10, 0xf000L); + case 88: + case 120: + if ((active6 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(13, 420, 89); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa14_1(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_1(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa14_1(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(12, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 14; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0xa00f0000000L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active6 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(14, 410, 89); + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x20L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(14, 98, 89); + else if ((active1 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(14, 101, 89); + else if ((active4 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_1(14, 317, 89); + else if ((active9 & 0x800000000L) != 0L) + return jjStartNfaWithStates_1(14, 611, 89); + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x4080000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x14001c000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(14, 118, 89); + else if ((active7 & 0x8000000L) != 0L) + return jjStartNfaWithStates_1(14, 475, 89); + else if ((active9 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_1(14, 627, 89); + return jjMoveStringLiteralDfa15_1(active0, 0x800000L, active1, 0L, active2, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active7 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(14, 463, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa15_1(active0, 0x1000000L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x80000L, active2, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x200000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(14, 40, 89); + else if ((active9 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(14, 588, 89); + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x40L, active2, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x8000000006000000L, active2, 0xc00000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2700000000L, active9, 0xc0000000000L, active10, 0L); + case 82: + case 114: + if ((active8 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(14, 554, 89); + else if ((active8 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_1(14, 571, 89); + break; + case 83: + case 115: + if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_1(14, 72, 89); + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x80L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x2000000L) != 0L) + return jjStartNfaWithStates_1(14, 409, 89); + else if ((active9 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(14, 614, 89); + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0x100000000000010L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0L, active2, 0x180L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active9 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(14, 593, 89); + else if ((active9 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(14, 623, 89); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa15_1(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + default : + break; + } + return jjStartNfa_1(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa15_1(long old0, long active0, long old1, long active1, long old2, long active2, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(13, old0, old1, old2, 0L, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 15; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x200000L) != 0L) + return jjStartNfaWithStates_1(15, 85, 89); + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x60L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0x400000000010L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_1(15, 23, 89); + break; + case 72: + case 104: + if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_1(15, 68, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x4000004000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 15; + } + else if ((active2 & 0x400000000000L) != 0L) + { + jjmatchedKind = 174; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_1(active0, 0x1000000L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x80000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 82: + case 114: + if ((active1 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(15, 95, 89); + else if ((active8 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(15, 555, 89); + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x700000000L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x10000000L) != 0L) + { + jjmatchedKind = 540; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa16_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + default : + break; + } + return jjStartNfa_1(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa16_1(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(14, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 16; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(16, 102, 89); + return jjMoveStringLiteralDfa17_1(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 69: + case 101: + if ((active7 & 0x20000L) != 0L) + return jjStartNfaWithStates_1(16, 465, 89); + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0xf000L); + case 71: + case 103: + if ((active1 & 0x80000L) != 0L) + return jjStartNfaWithStates_1(16, 83, 89); + break; + case 72: + case 104: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0x8000000000000040L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + if ((active1 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_1(16, 126, 89); + break; + case 82: + case 114: + if ((active8 & 0x100000000L) != 0L) + { + jjmatchedKind = 544; + jjmatchedPos = 16; + } + else if ((active8 & 0x8000000000L) != 0L) + { + jjmatchedKind = 551; + jjmatchedPos = 16; + } + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0x100000000000020L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa17_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active5 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_1(16, 366, 89); + break; + case 89: + case 121: + if ((active8 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(16, 553, 89); + break; + default : + break; + } + return jjStartNfa_1(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa17_1(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(15, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0x8000000000000000L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_1(17, 70, 89); + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(17, 100, 89); + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_1(17, 549, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa18_1(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 82: + case 114: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18e0000000L, active9, 0L, active10, 0x20000000000000L); + case 86: + case 118: + return jjMoveStringLiteralDfa18_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_1(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa18_1(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(16, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 18; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0x80L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x3000L); + case 68: + case 100: + if ((active8 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_1(18, 550, 89); + else if ((active8 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_1(18, 566, 89); + else if ((active8 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(18, 568, 89); + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x800000000L) != 0L) + { + jjmatchedKind = 547; + jjmatchedPos = 18; + } + else if ((active9 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_1(18, 617, 89); + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa19_1(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4000L); + case 79: + case 111: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0x100L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 84: + case 116: + return jjMoveStringLiteralDfa19_1(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0x4000L, active8, 0x10600000000L, active9, 0x40000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_1(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa19_1(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(17, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 19; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10e0000000L, active9, 0x80000000000L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_1(19, 71, 89); + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x5000L); + case 67: + case 99: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x1000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 68: + case 100: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x10L) != 0L) + return jjStartNfaWithStates_1(19, 324, 89); + break; + case 78: + case 110: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0x2000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0x20L, active2, 0x80L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0x20000000002000L); + case 82: + case 114: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0x8000000000000000L, active2, 0x100L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa20_1(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa20_1(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 89: + case 121: + if ((active7 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(19, 462, 89); + break; + default : + break; + } + return jjStartNfa_1(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa20_1(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(18, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); + return 20; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0x3000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0x80L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000L); + case 69: + case 101: + if ((active1 & 0x4000000L) != 0L) + return jjStartNfaWithStates_1(20, 90, 89); + else if ((active2 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_1(20, 175, 89); + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0x100L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_1(20, 69, 89); + break; + case 72: + case 104: + if ((active7 & 0x10000L) != 0L) + return jjStartNfaWithStates_1(20, 464, 89); + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x20000000L, active9, 0L, active10, 0x8000L); + case 77: + case 109: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x40000000L, active9, 0L, active10, 0x4000L); + case 78: + case 110: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0x100000000000000L, active2, 0L, active6, 0x800L, active7, 0L, active8, 0x80000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa21_1(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0x1000L); + case 89: + case 121: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_1(20, 24, 89); + break; + default : + break; + } + return jjStartNfa_1(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa21_1(long old0, long active0, long old1, long active1, long old2, long active2, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(19, old0, old1, old2, 0L, 0L, 0L, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 21; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 65: + case 97: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0x80000000000L, active10, 0x1000L); + case 67: + case 99: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_1(21, 618, 89); + break; + case 69: + case 101: + if ((active2 & 0x80L) != 0L) + return jjStartNfaWithStates_1(21, 135, 89); + else if ((active10 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(21, 653, 89); + else if ((active10 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(21, 654, 89); + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x8000L); + case 70: + case 102: + return jjMoveStringLiteralDfa22_1(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0x800L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0x2000L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x1020000000L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa22_1(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa22_1(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_1(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa22_1(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(20, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 22; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active6 & 0x2000L) != 0L) + return jjStartNfaWithStates_1(22, 397, 89); + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x200000000L, active9, 0L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x1000L); + case 77: + case 109: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000008000L); + case 78: + case 110: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa23_1(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0x10000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa23_1(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa23_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x20000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_1(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa23_1(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(21, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 23; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa24_1(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active10 & 0x8000L) != 0L) + return jjStartNfaWithStates_1(23, 655, 89); + break; + case 67: + case 99: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 75: + case 107: + if ((active9 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_1(23, 619, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x20000000001000L); + case 82: + case 114: + if ((active8 & 0x20000000L) != 0L) + return jjStartNfaWithStates_1(23, 541, 89); + return jjMoveStringLiteralDfa24_1(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa24_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_1(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa24_1(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_1(22, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 24; + } + switch(curChar) + { + case 65: + case 97: + if ((active6 & 0x4000L) != 0L) + return jjStartNfaWithStates_1(24, 398, 89); + break; + case 68: + case 100: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active10, 0x20000000000000L); + case 69: + case 101: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa25_1(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 71: + case 103: + if ((active10 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(24, 652, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa25_1(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0x1800L, active8, 0x400000000L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x10040000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa25_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_1(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa25_1(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_1(23, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 25; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa26_1(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa26_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x80000000L) != 0L) + return jjStartNfaWithStates_1(25, 543, 89); + break; + case 69: + case 101: + if ((active8 & 0x40000000L) != 0L) + return jjStartNfaWithStates_1(25, 542, 89); + else if ((active10 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_1(25, 693, 89); + break; + case 71: + case 103: + if ((active6 & 0x1000L) != 0L) + return jjStartNfaWithStates_1(25, 396, 89); + break; + case 72: + case 104: + if ((active8 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_1(25, 552, 89); + break; + case 78: + case 110: + if ((active6 & 0x800L) != 0L) + return jjStartNfaWithStates_1(25, 395, 89); + return jjMoveStringLiteralDfa26_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa26_1(active1, 0x8000000000000000L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa26_1(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_1(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa26_1(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_1(24, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 26; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x400000000L) != 0L) + return jjStartNfaWithStates_1(26, 546, 89); + break; + case 69: + case 101: + if ((active8 & 0x200000000L) != 0L) + return jjStartNfaWithStates_1(26, 545, 89); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa27_1(active1, 0x100000000000000L, active2, 0L, active8, 0L); + case 78: + case 110: + if ((active2 & 0x100L) != 0L) + return jjStartNfaWithStates_1(26, 136, 89); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa27_1(active1, 0L, active2, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa27_1(active1, 0x8000000000000000L, active2, 0L, active8, 0L); + default : + break; + } + return jjStartNfa_1(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa27_1(long old1, long active1, long old2, long active2, long old8, long active8) +{ + if (((active1 &= old1) | (active2 &= old2) | (active8 &= old8)) == 0L) + return jjStartNfa_1(25, 0L, old1, old2, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 27; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa28_1(active1, 0x8000000000000000L, active8, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa28_1(active1, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa28_1(active1, 0x100000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_1(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa28_1(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_1(26, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 28; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_1(28, 548, 89); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa29_1(active1, 0x100000000000000L, active8, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa29_1(active1, 0x8000000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_1(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa29_1(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_1(27, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 29; + } + switch(curChar) + { + case 85: + case 117: + return jjMoveStringLiteralDfa30_1(active1, 0x100000000000000L); + case 89: + case 121: + return jjMoveStringLiteralDfa30_1(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_1(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa30_1(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_1(28, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 30; + } + switch(curChar) + { + case 80: + case 112: + if ((active1 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_1(30, 120, 89); + return jjMoveStringLiteralDfa31_1(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_1(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa31_1(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_1(29, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_1(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 31; + } + switch(curChar) + { + case 69: + case 101: + if ((active1 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_1(31, 127, 89); + break; + default : + break; + } + return jjStartNfa_1(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private final void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private final void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} +private final void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} +private final void jjCheckNAddStates(int start) +{ + jjCheckNAdd(jjnextStates[start]); + jjCheckNAdd(jjnextStates[start + 1]); +} +static final long[] jjbitVec0 = { + 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec2 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec3 = { + 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L +}; +static final long[] jjbitVec4 = { + 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec5 = { + 0x3fffffffffL, 0x0L, 0x0L, 0x0L +}; +static final long[] jjbitVec6 = { + 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec7 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L +}; +static final long[] jjbitVec8 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L +}; +static final long[] jjbitVec9 = { + 0x3fffffffffffL, 0x0L, 0x0L, 0x0L +}; +private final int jjMoveNfa_1(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 86; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 86: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(3, 5); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 87: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(6, 8); + else if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 84: + if (curChar == 47) + { + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + } + else if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 82; + break; + case 58: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 59; + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 55: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + else if (curChar == 39) + { + if (kind > 720) + kind = 720; + } + if ((0xfc00f7faffffc9ffL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 88: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 91: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if (curChar == 36) + jjCheckNAdd(31); + break; + case 90: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 1: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(15, 17); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 0: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 47) + jjAddStates(18, 19); + else if (curChar == 39) + jjCheckNAddStates(20, 23); + else if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + else if (curChar == 7) + { + if (kind > 786) + kind = 786; + } + else if (curChar == 34) + jjCheckNAddTwoStates(22, 24); + else if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + } + else if (curChar == 36) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 2: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(15, 17); + break; + case 3: + if (curChar == 39) + jjCheckNAddStates(15, 17); + break; + case 4: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 3; + break; + case 5: + if (curChar == 39 && kind > 719) + kind = 719; + break; + case 7: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7ff600000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 9: + case 11: + if (curChar == 39) + jjCheckNAddStates(3, 5); + break; + case 10: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 12: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 11; + break; + case 13: + if (curChar == 39 && kind > 721) + kind = 721; + break; + case 15: + if (curChar != 45) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 16: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 17: + if ((0x2400L & l) != 0L && kind > 772) + kind = 772; + break; + case 18: + if (curChar == 10 && kind > 772) + kind = 772; + break; + case 19: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 18; + break; + case 20: + if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + break; + case 21: + if (curChar == 34) + jjCheckNAddTwoStates(22, 24); + break; + case 22: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(6, 8); + break; + case 23: + if (curChar == 34) + jjCheckNAddStates(6, 8); + break; + case 24: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 25: + if (curChar == 34 && kind > 777) + kind = 777; + break; + case 26: + if (curChar != 36) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 29: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 30: + if (curChar == 36) + jjCheckNAdd(31); + break; + case 31: + if (curChar != 36) + break; + if (kind > 782) + kind = 782; + jjCheckNAddTwoStates(31, 32); + break; + case 32: + if (curChar == 36) + jjCheckNAdd(33); + break; + case 33: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjCheckNAdd(33); + break; + case 34: + if (curChar == 7 && kind > 786) + kind = 786; + break; + case 35: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + break; + case 36: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAdd(36); + break; + case 37: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(37, 38); + break; + case 39: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(40); + break; + case 40: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 714) + kind = 714; + jjCheckNAdd(40); + break; + case 41: + if (curChar == 46) + jjCheckNAddTwoStates(42, 38); + break; + case 42: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(42, 38); + break; + case 43: + if (curChar != 46) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 44: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 45: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAddStates(31, 33); + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(34, 37); + break; + case 47: + if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + break; + case 48: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 49: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + break; + case 50: + if (curChar == 39) + jjCheckNAddStates(20, 23); + break; + case 51: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 52: + if (curChar == 39) + jjCheckNAddStates(12, 14); + break; + case 53: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 54: + if (curChar == 39 && kind > 720) + kind = 720; + break; + case 56: + if (curChar == 39 && kind > 726) + kind = 726; + break; + case 59: + case 61: + if (curChar == 39) + jjCheckNAddStates(38, 40); + break; + case 60: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(38, 40); + break; + case 62: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 61; + break; + case 63: + if (curChar == 39 && kind > 722) + kind = 722; + break; + case 64: + if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + break; + case 65: + if (curChar == 34) + jjCheckNAddTwoStates(66, 68); + break; + case 66: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(41, 43); + break; + case 67: + if (curChar == 34) + jjCheckNAddStates(41, 43); + break; + case 68: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 67; + break; + case 69: + if (curChar == 34 && kind > 783) + kind = 783; + break; + case 71: + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 73: + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + break; + case 75: + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + break; + case 78: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + break; + case 81: + if (curChar == 47) + jjAddStates(18, 19); + break; + case 82: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 83; + break; + case 83: + if ((0xffff7fffffffffffL & l) != 0L && kind > 770) + kind = 770; + break; + case 85: + if (curChar != 47) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 86: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 87: + case 22: + jjCheckNAddStates(6, 8); + break; + case 58: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 55: + jjCheckNAddStates(12, 14); + if ((0xffffff81ffffff81L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 88: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + else if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + else if ((0x1000000010L & l) != 0L) + { + if (kind > 729) + kind = 729; + } + if ((0x10000000100000L & l) != 0L) + { + if (kind > 730) + kind = 730; + } + break; + case 91: + case 29: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 123) + jjAddStates(44, 51); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + else if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + else if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 1; + else if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 2: + jjAddStates(15, 17); + break; + case 6: + if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 7: + if ((0x7fffffe07fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 10: + jjAddStates(3, 5); + break; + case 14: + if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + break; + case 16: + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 26: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 31: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 38: + if ((0x2000000020L & l) != 0L) + jjAddStates(56, 57); + break; + case 51: + jjCheckNAddStates(12, 14); + break; + case 57: + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + break; + case 60: + jjAddStates(38, 40); + break; + case 66: + jjAddStates(41, 43); + break; + case 70: + if (curChar == 123) + jjAddStates(44, 51); + break; + case 72: + if ((0x1000000010L & l) != 0L && kind > 729) + kind = 729; + break; + case 74: + if ((0x10000000100000L & l) != 0L && kind > 730) + kind = 730; + break; + case 76: + if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + break; + case 77: + if ((0x8000000080000L & l) != 0L && kind > 731) + kind = 731; + break; + case 79: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + break; + case 80: + if ((0x400000004000L & l) != 0L && kind > 732) + kind = 732; + break; + case 83: + if (kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 86: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 87: + case 22: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(6, 8); + break; + case 58: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 55: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 91: + case 29: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 0: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 2: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(15, 17); + break; + case 10: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(3, 5); + break; + case 16: + if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) + break; + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 26: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 31: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 51: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + break; + case 60: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(38, 40); + break; + case 66: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(41, 43); + break; + case 83: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 86 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + switch (pos) + { + case 0: + if ((active5 & 0x1fffffc00000L) != 0L || (active10 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + return 86; + } + if ((active10 & 0x80000000000L) != 0L) + { + jjmatchedKind = 781; + return 1; + } + if ((active11 & 0x20000000L) != 0L) + return 87; + if ((active11 & 0x80000000L) != 0L) + return 88; + if ((active9 & 0xf000000000000000L) != 0L || (active10 & 0xfffffL) != 0L || (active11 & 0x100L) != 0L) + { + jjmatchedKind = 781; + return 58; + } + if ((active11 & 0x20000000000000L) != 0L) + return 55; + if ((active11 & 0x1000000000000L) != 0L || (active12 & 0x9L) != 0L) + return 84; + if ((active0 & 0x7ffe000000000L) != 0L || (active2 & 0xfffffffffffffff0L) != 0L || (active3 & 0xffffe0007fffffffL) != 0L || (active4 & 0x7ffffe1fffffffL) != 0L || (active5 & 0xffffe00000000000L) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0x7fffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xfffffffffffffffL) != 0L || (active10 & 0x7f27f7fffff00000L) != 0L || (active11 & 0x95L) != 0L) + { + jjmatchedKind = 781; + return 89; + } + if ((active11 & 0x400000000000L) != 0L) + return 15; + if ((active0 & 0xfff8001ffffffff8L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfL) != 0L || (active3 & 0x1fff80000000L) != 0L || (active4 & 0xff800001e0000000L) != 0L || (active5 & 0x3fffffL) != 0L || (active7 & 0x8000000000000000L) != 0L || (active10 & 0xd8000000000000L) != 0L || (active11 & 0x20000000000006aL) != 0L) + return 89; + if ((active11 & 0x10000400000000L) != 0L) + return 90; + return -1; + case 1: + if ((active12 & 0x9L) != 0L) + return 82; + if ((active0 & 0x40007fe000000L) != 0L || (active3 & 0xfc00006000000000L) != 0L || (active4 & 0x200000007ffffL) != 0L || (active5 & 0x78e6001f00000000L) != 0L || (active9 & 0x6000000000L) != 0L || (active10 & 0xa811000000000000L) != 0L || (active11 & 0x40L) != 0L) + return 89; + if ((active0 & 0xfff3fff801fffff0L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xffffffffffffffffL) != 0L || (active3 & 0x3ffff9f7fffffffL) != 0L || (active4 & 0xff7dffffdff80000L) != 0L || (active5 & 0x8719ffe0ffffffffL) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0xffffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xffffff9fffffffffL) != 0L || (active10 & 0x57eeffffffffffffL) != 0L || (active11 & 0x1bfL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 781; + jjmatchedPos = 1; + } + return 89; + } + return -1; + case 2: + if ((active0 & 0xfff3dfef79e98c80L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfe1ff2ffffff09ffL) != 0L || (active3 & 0xfbfeffd77f87ff9fL) != 0L || (active4 & 0x3e7dfffa1fff40ffL) != 0L || (active5 & 0xf795ffeebffe03ffL) != 0L || (active6 & 0xf8fffffdc07fff78L) != 0L || (active7 & 0x1ffffffc3fffffffL) != 0L || (active8 & 0xfffL) != 0L || (active9 & 0xffffffdffff7fffeL) != 0L || (active10 & 0xfffef7ffffffffffL) != 0L || (active11 & 0x1ffL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 781; + jjmatchedPos = 2; + } + return 89; + } + if ((active0 & 0x201004167370L) != 0L || (active2 & 0x1e00d000000f600L) != 0L || (active3 & 0x1000800780060L) != 0L || (active4 & 0xc1000005c0003f00L) != 0L || (active5 & 0x4800104001fc00L) != 0L || (active6 & 0x70000023f800087L) != 0L || (active7 & 0xe0000003c0000000L) != 0L || (active8 & 0xfffffffffffff000L) != 0L || (active9 & 0x80001L) != 0L || (active10 & 0x80000000000L) != 0L) + return 89; + return -1; + case 3: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x99c29fef79e9ece0L) != 0L || (active1 & 0xfff7cfffffffdc01L) != 0L || (active2 & 0xff9ae2fe1fffe80fL) != 0L || (active3 & 0xfbf87f9763f7ffd3L) != 0L || (active4 & 0xbe7d389b80075effL) != 0L || (active5 & 0xf605f86c3f37bbffL) != 0L || (active6 & 0xfe87f7fcff4fff06L) != 0L || (active7 & 0x9febfffdbf7fffffL) != 0L || (active8 & 0xffffffffffffefa6L) != 0L || (active9 & 0xf63fffd00ff7fffdL) != 0L || (active10 & 0xfefe061c3ffd07ffL) != 0L || (active11 & 0xf9L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 781; + jjmatchedPos = 3; + } + return 89; + } + if ((active0 & 0x6631400000000000L) != 0L || (active1 & 0x83000000023feL) != 0L || (active2 & 0x51001e00005f0L) != 0L || (active3 & 0x680401c00000cL) != 0L || (active4 & 0xc7601ff82000L) != 0L || (active5 & 0x190078280c80000L) != 0L || (active6 & 0x78080100300078L) != 0L || (active7 & 0x4014000200800000L) != 0L || (active8 & 0x59L) != 0L || (active9 & 0x9c0000ff0000002L) != 0L || (active10 & 0x100f1e3c002f800L) != 0L || (active11 & 0x106L) != 0L) + return 89; + return -1; + case 4: + if ((active0 & 0xd9e29e2f780120e0L) != 0L || (active1 & 0xfff3affffffe9bfcL) != 0L || (active2 & 0xd592e2ffd3ffe9a7L) != 0L || (active3 & 0xfbd86017637413dbL) != 0L || (active4 & 0x8020aac99fc75ef1L) != 0L || (active5 & 0xc605fb2c2711bbfbL) != 0L || (active6 & 0xfe83d7dcbf4fff74L) != 0L || (active7 & 0x1febf0ddbf1ffeffL) != 0L || (active8 & 0xffffffffffffeea6L) != 0L || (active9 & 0xf6bdffdf88f7f7e1L) != 0L || (active10 & 0xf5de02da3f80f2fcL) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 781; + jjmatchedPos = 4; + } + return 89; + } + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x1c001e8cc00L) != 0L || (active1 & 0x4400000014401L) != 0L || (active2 & 0x2a0800000c000008L) != 0L || (active3 & 0x241f800083ec00L) != 0L || (active4 & 0x3e5d10120000000eL) != 0L || (active5 & 0x3000044018a60004L) != 0L || (active6 & 0x24202040000002L) != 0L || (active7 & 0x80000f2000600100L) != 0L || (active8 & 0x100L) != 0L || (active9 & 0x200000700081cL) != 0L || (active10 & 0xa202404007d0503L) != 0L || (active11 & 0xc0L) != 0L) + return 89; + return -1; + case 5: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0xd9c2878e79c02040L) != 0L || (active1 & 0xfff1afffe67e9bfcL) != 0L || (active2 & 0x192e07fd20fc9a1L) != 0L || (active3 & 0xf9c84d072364834bL) != 0L || (active4 & 0xbc38a2c99fc65ed1L) != 0L || (active5 & 0x6000d12c2710a3b9L) != 0L || (active6 & 0xfe82d7dcaf4dff70L) != 0L || (active7 & 0x19e30e0dbd000effL) != 0L || (active8 & 0xffffffffffffee22L) != 0L || (active9 & 0xf2bdffdf8e17b6d1L) != 0L || (active10 & 0xf7ee028a3fc0f038L) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 781; + jjmatchedPos = 5; + } + return 89; + } + if ((active0 & 0x201821000100a0L) != 0L || (active1 & 0x2000019800000L) != 0L || (active2 & 0xd400028001f02006L) != 0L || (active3 & 0x210301040101090L) != 0L || (active4 & 0x80000010020L) != 0L || (active5 & 0x86052a0000051842L) != 0L || (active6 & 0x1000010020004L) != 0L || (active7 & 0x608f0d0021ff000L) != 0L || (active8 & 0x84L) != 0L || (active9 & 0x400000000e04120L) != 0L || (active10 & 0x100050002002c4L) != 0L) + return 89; + return -1; + case 6: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x40038e79c02040L) != 0L || (active1 & 0x11a7f8f73c9bfcL) != 0L || (active2 & 0x8190007fc20c09a4L) != 0L || (active3 & 0x71c84c0623048102L) != 0L || (active4 & 0xb01880499fc41cd0L) != 0L || (active5 & 0x6000c12c0310a3b9L) != 0L || (active6 & 0x7e80c5d800097f50L) != 0L || (active7 & 0x5e20e898107c85fL) != 0L || (active8 & 0xfffffffffffbee20L) != 0L || (active9 & 0xe281ffcf8ed7b6d1L) != 0L || (active10 & 0xb7fa000a0340f000L) != 0L || (active11 & 0x9L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 781; + jjmatchedPos = 6; + } + return 89; + } + if ((active0 & 0xd982840000000000L) != 0L || (active1 & 0xffe0080700420000L) != 0L || (active2 & 0x2e0001063c001L) != 0L || (active3 & 0x8800010100600249L) != 0L || (active4 & 0xc20228000024201L) != 0L || (active5 & 0x400100024001000L) != 0L || (active6 & 0x80021204af448020L) != 0L || (active7 & 0x180180043c0806a0L) != 0L || (active8 & 0x40002L) != 0L || (active9 & 0x103c001000000000L) != 0L || (active10 & 0x400402803c800038L) != 0L || (active11 & 0x30L) != 0L) + return 89; + return -1; + case 7: + if ((active2 & 0x40000000000000L) != 0L) + return 91; + if ((active0 & 0x1040038e79c00000L) != 0L || (active1 & 0xffd1a1fef73c1bfcL) != 0L || (active2 & 0x8180c01782040985L) != 0L || (active3 & 0x71c0440203048002L) != 0L || (active4 & 0x301880409fc40c91L) != 0L || (active5 & 0x4000c02c010003b8L) != 0L || (active6 & 0x7e80c1800e097f40L) != 0L || (active7 & 0x15600e89b807c041L) != 0L || (active8 & 0xfff2ffffff13a000L) != 0L || (active9 & 0xe0b9ff4f8ed3b6d1L) != 0L || (active10 & 0xa7f800082200f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 7) + { + jjmatchedKind = 781; + jjmatchedPos = 7; + } + return 89; + } + if ((active0 & 0x100000000002040L) != 0L || (active1 & 0x60000008000L) != 0L || (active2 & 0x100068400a0020L) != 0L || (active3 & 0x8080420000100L) != 0L || (active4 & 0x8000000900001040L) != 0L || (active5 & 0x200001000210a001L) != 0L || (active6 & 0x45800000010L) != 0L || (active7 & 0x8200000100081eL) != 0L || (active8 & 0xd000000e84e20L) != 0L || (active9 & 0x200008000040000L) != 0L || (active10 & 0x1002000201400000L) != 0L || (active11 & 0x1L) != 0L) + return 89; + return -1; + case 8: + if ((active0 & 0x20610400000L) != 0L || (active1 & 0x108000f03c03f8L) != 0L || (active2 & 0x8080000000000000L) != 0L || (active3 & 0x70c0400202040002L) != 0L || (active4 & 0x18000000040c01L) != 0L || (active5 & 0x2c00000000L) != 0L || (active6 & 0x1880818000017f00L) != 0L || (active7 & 0x60000880040000L) != 0L || (active8 & 0x300004000000L) != 0L || (active9 & 0x2000f00388130410L) != 0L || (active10 & 0x8410000002000000L) != 0L) + return 89; + if ((active0 & 0x1040018869800000L) != 0L || (active1 & 0xffc121fe07001804L) != 0L || (active2 & 0x100c01782040985L) != 0L || (active3 & 0x100040001008000L) != 0L || (active4 & 0x300080409fc00090L) != 0L || (active5 & 0x4000c000010003b8L) != 0L || (active6 & 0x660040100e080040L) != 0L || (active7 & 0x15000e813803c041L) != 0L || (active8 & 0xfffacffffb13ac00L) != 0L || (active9 & 0xc0b90f4c06c0b2c1L) != 0L || (active10 & 0x23e800082000f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 8) + { + jjmatchedKind = 781; + jjmatchedPos = 8; + } + return 89; + } + return -1; + case 9: + if ((active0 & 0x468000000L) != 0L || (active1 & 0x100fe00000a00L) != 0L || (active2 & 0x1102040800L) != 0L || (active4 & 0x804098c00000L) != 0L || (active5 & 0x4000000801000200L) != 0L || (active6 & 0x2200400000000040L) != 0L || (active7 & 0x40100000041L) != 0L || (active8 & 0x2038000L) != 0L || (active9 & 0x80200002008240L) != 0L || (active10 & 0x280000020000000L) != 0L || (active11 & 0x8L) != 0L) + return 89; + if ((active0 & 0x1040018801800000L) != 0L || (active1 & 0xffc02100c73811f4L) != 0L || (active2 & 0x100c00680000185L) != 0L || (active3 & 0x180040001008000L) != 0L || (active4 & 0x3010000007000890L) != 0L || (active5 & 0xc000000001b8L) != 0L || (active6 & 0x440000100e087e00L) != 0L || (active7 & 0x15000a803803c000L) != 0L || (active8 & 0xfffacffff9102c00L) != 0L || (active9 & 0xc0398f4f04c23081L) != 0L || (active10 & 0x216800080000f000L) != 0L) + { + if (jjmatchedPos != 9) + { + jjmatchedKind = 781; + jjmatchedPos = 9; + } + return 89; + } + return -1; + case 10: + if ((active0 & 0x1000010801800000L) != 0L || (active1 & 0xf7c02074863811f0L) != 0L || (active2 & 0x100c00200000181L) != 0L || (active3 & 0x100040000000000L) != 0L || (active4 & 0x3010000000800880L) != 0L || (active5 & 0xc00000000038L) != 0L || (active6 & 0x400000100e007e00L) != 0L || (active7 & 0x11000a003803c000L) != 0L || (active8 & 0xffca8ffff0002c00L) != 0L || (active9 & 0x8038804f00021000L) != 0L || (active10 & 0x2800080000f000L) != 0L) + { + if (jjmatchedPos != 10) + { + jjmatchedKind = 781; + jjmatchedPos = 10; + } + return 89; + } + if ((active0 & 0x40008000000000L) != 0L || (active1 & 0x800018041000004L) != 0L || (active2 & 0x480000004L) != 0L || (active3 & 0x80000001008000L) != 0L || (active4 & 0x7000010L) != 0L || (active5 & 0x180L) != 0L || (active6 & 0x400000000080000L) != 0L || (active7 & 0x400008000000000L) != 0L || (active8 & 0x30400009100000L) != 0L || (active9 & 0x40010f0004c02081L) != 0L || (active10 & 0x2140000000000000L) != 0L) + return 89; + return -1; + case 11: + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x6680000000001000L) != 0L || (active2 & 0x1L) != 0L || (active3 & 0x40000000000L) != 0L || (active4 & 0x1000000000000880L) != 0L || (active5 & 0x800000000020L) != 0L || (active6 & 0x8000000L) != 0L || (active7 & 0x1100080010000000L) != 0L || (active8 & 0x6082800000002800L) != 0L || (active9 & 0x10000100000000L) != 0L || (active10 & 0x8000800000000L) != 0L) + return 89; + if ((active0 & 0x10801800000L) != 0L || (active1 & 0x91402074863801f0L) != 0L || (active2 & 0x100c00200000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004800000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x9f480ffff0000400L) != 0L || (active9 & 0x80288e4e00021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 11) + { + jjmatchedKind = 781; + jjmatchedPos = 11; + } + return 89; + } + return -1; + case 12: + if ((active0 & 0x800000000L) != 0L || (active1 & 0x200000000000L) != 0L || (active2 & 0x100000200000000L) != 0L || (active4 & 0x800000L) != 0L || (active8 & 0x8408000000000400L) != 0L || (active9 & 0x8000000600000000L) != 0L) + return 89; + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xd1400074863801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004000000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x1b400ffff0000000L) != 0L || (active9 & 0x288e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 12; + return 89; + } + return -1; + case 13: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xc1400074862801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x6007800L) != 0L || (active7 & 0x803c000L) != 0L || (active8 & 0x9400ffff0000000L) != 0L || (active9 & 0x88e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 13; + return 89; + } + if ((active1 & 0x1000000000100000L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x10000004000000L) != 0L || (active5 & 0x8L) != 0L || (active6 & 0x4000001000000600L) != 0L || (active7 & 0x20020000000L) != 0L || (active8 & 0x1200000000000000L) != 0L || (active9 & 0x20000000000000L) != 0L) + return 89; + return -1; + case 14: + if ((active0 & 0x1800000L) != 0L || (active1 & 0xc1000050862800f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x1400bfff0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 14; + return 89; + } + if ((active0 & 0x10000000000L) != 0L || (active1 & 0x40002400000100L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active6 & 0x6000000L) != 0L || (active7 & 0x8008000L) != 0L || (active8 & 0x800040000000000L) != 0L || (active9 & 0x8804800021000L) != 0L) + return 89; + return -1; + case 15: + if ((active0 & 0x1000000L) != 0L || (active1 & 0xc1000050000800e0L) != 0L || (active2 & 0x180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x14003ff00000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 15) + { + jjmatchedKind = 781; + jjmatchedPos = 15; + } + return 89; + } + if ((active0 & 0x800000L) != 0L || (active1 & 0x86200010L) != 0L || (active2 & 0xc00000000000L) != 0L || (active8 & 0x800f0000000L) != 0L) + return 89; + return -1; + case 16: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000010040000e0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x1400078e0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 16) + { + jjmatchedKind = 781; + jjmatchedPos = 16; + } + return 89; + } + if ((active1 & 0x4000004000080000L) != 0L || (active5 & 0x400000000000L) != 0L || (active7 & 0x20000L) != 0L || (active8 & 0x38700000000L) != 0L) + return 89; + return -1; + case 17: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x140015ee0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 17; + return 89; + } + if ((active1 & 0x1000000040L) != 0L || (active8 & 0x2000000000L) != 0L) + return 89; + return -1; + case 18: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x106e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 18) + { + jjmatchedKind = 781; + jjmatchedPos = 18; + } + return 89; + } + if ((active8 & 0x140005800000000L) != 0L || (active9 & 0x20000000000L) != 0L) + return 89; + return -1; + case 19: + if ((active1 & 0x80L) != 0L || (active5 & 0x10L) != 0L || (active7 & 0x4000L) != 0L) + return 89; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x8100000004000020L) != 0L || (active2 & 0x800000000180L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x10000L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 19; + return 89; + } + return -1; + case 20: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x180L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 20; + return 89; + } + if ((active0 & 0x1000000L) != 0L || (active1 & 0x4000020L) != 0L || (active2 & 0x800000000000L) != 0L || (active7 & 0x10000L) != 0L) + return 89; + return -1; + case 21: + if ((active2 & 0x80L) != 0L || (active9 & 0x40000000000L) != 0L || (active10 & 0x6000L) != 0L) + return 89; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 21; + return 89; + } + return -1; + case 22: + if ((active6 & 0x2000L) != 0L) + return 89; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 22; + return 89; + } + return -1; + case 23: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000001000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 23; + return 89; + } + if ((active8 & 0x20000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x8000L) != 0L) + return 89; + return -1; + case 24: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x1800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 24; + return 89; + } + if ((active6 & 0x4000L) != 0L || (active10 & 0x1000L) != 0L) + return 89; + return -1; + case 25: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active8 & 0x1600000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 25; + return 89; + } + if ((active6 & 0x1800L) != 0L || (active8 & 0x100c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + return 89; + return -1; + case 26: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 26; + return 89; + } + if ((active2 & 0x100L) != 0L || (active8 & 0x600000000L) != 0L) + return 89; + return -1; + case 27: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 27; + return 89; + } + return -1; + case 28: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 28; + return 89; + } + if ((active8 & 0x1000000000L) != 0L) + return 89; + return -1; + case 29: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 29; + return 89; + } + return -1; + case 30: + if ((active1 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 30; + return 89; + } + if ((active1 & 0x100000000000000L) != 0L) + return 89; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12), pos + 1); +} +private final int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 1; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000L, 0x0L); + case 34: + return jjStopAtPos(0, 758); + case 36: + return jjStartNfaWithStates_0(0, 761, 89); + case 37: + return jjStopAtPos(0, 753); + case 39: + return jjStartNfaWithStates_0(0, 757, 55); + case 40: + return jjStopAtPos(0, 727); + case 41: + return jjStopAtPos(0, 728); + case 42: + jjmatchedKind = 751; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L); + case 43: + return jjStopAtPos(0, 749); + case 44: + return jjStopAtPos(0, 739); + case 45: + return jjStartNfaWithStates_0(0, 750, 15); + case 46: + jjmatchedKind = 738; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x10000000000000L, 0x0L); + case 47: + jjmatchedKind = 752; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x9L); + case 58: + jjmatchedKind = 744; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L); + case 59: + return jjStopAtPos(0, 737); + case 60: + jjmatchedKind = 742; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xa0000000000L, 0x0L); + case 61: + jjmatchedKind = 740; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000L, 0x0L); + case 62: + jjmatchedKind = 741; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x40000000000L, 0x0L); + case 63: + return jjStopAtPos(0, 743); + case 91: + return jjStartNfaWithStates_0(0, 735, 88); + case 93: + return jjStopAtPos(0, 736); + case 94: + return jjStopAtPos(0, 760); + case 65: + case 97: + jjmatchedKind = 3; + return jjMoveStringLiteralDfa1_0(0x1ffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x18000000000000L, 0x40L, 0x0L); + case 66: + case 98: + return jjMoveStringLiteralDfa1_0(0x7ffe000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L, 0x0L); + case 67: + case 99: + jjmatchedKind = 51; + return jjMoveStringLiteralDfa1_0(0xfff0000000000000L, 0xffffffffffffffffL, 0xfL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xc0000000000000L, 0x28L, 0x0L); + case 68: + case 100: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0xfffffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000000L, 0x0L, 0x0L); + case 69: + case 101: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0xffff000000000000L, 0x3ffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L, 0x0L); + case 70: + case 102: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x7ffffc00L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 71: + case 103: + jjmatchedKind = 223; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x1fff00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 72: + case 104: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x7e00000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 73: + case 105: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0xfff8000000000000L, 0x7ffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2801000000000000L, 0x0L, 0x0L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x1ff80000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 75: + case 107: + jjmatchedKind = 285; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x1c0000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L, 0x0L); + case 76: + case 108: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffe00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000000L, 0x0L, 0x0L); + case 77: + case 109: + jjmatchedKind = 311; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0xff00000000000000L, 0x3fffffL, 0x0L, 0x8000000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 78: + case 110: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1fffffc00000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000000L, 0x0L, 0x0L); + case 79: + case 111: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xffffe00000000000L, 0x7fL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 80: + case 112: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1ffffffffff80L, 0x0L, 0x0L, 0x0L, 0x1000000000000000L, 0x1L, 0x0L); + case 81: + case 113: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80L, 0x0L); + case 82: + case 114: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffc000000000000L, 0x7ffffffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 83: + case 115: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffff800000000L, 0xffffffffffffffffL, 0xffffffL, 0x800000000000L, 0x14L, 0x0L); + case 84: + case 116: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffffffff000000L, 0x2000000000000L, 0x0L, 0x0L); + case 85: + case 117: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xf000000000000000L, 0xfffffL, 0x100L, 0x0L); + case 86: + case 118: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x20000007ff00000L, 0x0L, 0x0L); + case 87: + case 119: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2007ff80000000L, 0x0L, 0x0L); + case 88: + case 120: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80000000000L, 0x0L, 0x0L); + case 89: + case 121: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x300000000000L, 0x0L, 0x0L); + case 90: + case 122: + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000L, 0x0L, 0x0L); + case 123: + return jjStartNfaWithStates_0(0, 733, 87); + case 124: + jjmatchedKind = 759; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L); + case 125: + return jjStopAtPos(0, 734); + case 126: + return jjStopAtPos(0, 2); + default : + return jjMoveNfa_0(0, 0); + } +} +private final int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 1; + } + switch(curChar) + { + case 42: + if ((active12 & 0x8L) != 0L) + { + jjmatchedKind = 771; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0x1L); + case 46: + if ((active11 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 756); + break; + case 47: + if ((active12 & 0x2L) != 0L) + return jjStopAtPos(1, 769); + break; + case 58: + if ((active11 & 0x400000000000000L) != 0L) + return jjStopAtPos(1, 762); + break; + case 61: + if ((active11 & 0x20000000000L) != 0L) + return jjStopAtPos(1, 745); + else if ((active11 & 0x40000000000L) != 0L) + return jjStopAtPos(1, 746); + else if ((active11 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 748); + break; + case 62: + if ((active11 & 0x80000000000L) != 0L) + return jjStopAtPos(1, 747); + else if ((active11 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 755); + break; + case 65: + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x1ff0000000000000L, active1, 0L, active2, 0x10000000007f0L, active3, 0x200000000400L, active4, 0xff0000fe00080000L, active5, 0x7c00000L, active6, 0xc0000007fff80L, active7, 0x800000000L, active8, 0L, active9, 0x7000000L, active10, 0x13c400000ff00000L, active11, 0x1L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa2_0(active0, 0x70L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa2_0(active0, 0x80L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1c00018000000L, active6, 0L, active7, 0x1ff000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x4L, active12, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa2_0(active0, 0x700L, active1, 0L, active2, 0L, active3, 0x8000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0xe00007e000000000L, active1, 0L, active2, 0x3fffff800L, active3, 0xf00000800L, active4, 0x1f01c0000000L, active5, 0xe000007fL, active6, 0xfff000003f800000L, active7, 0x7fffe000001fffffL, active8, 0L, active9, 0x1000000008000000L, active10, 0x2b000b0000000L, active11, 0x10L, active12, 0L); + case 70: + case 102: + if ((active5 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 369; + jjmatchedPos = 1; + } + else if ((active10 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(1, 688, 89); + return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x4000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000000000000L, active11, 0L, active12, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x10000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x7ffL, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1L, active9, 0x10000000L, active10, 0x700000000L, active11, 0L, active12, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x380000000000L, active1, 0L, active2, 0x7c00000000L, active3, 0x40000000f000L, active4, 0x1e00000000000L, active5, 0x3f80L, active6, 0x40000000L, active7, 0x8000000000200000L, active8, 0xeL, active9, 0x1fe0000000L, active10, 0xf840000000L, active11, 0x2L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x40000001f000L, active1, 0x7800L, active2, 0x6000000000000L, active3, 0x20001000030000L, active4, 0L, active5, 0x8000000000000L, active6, 0x380000000L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x8000000000000L, active3, 0x3c0000000000000L, active4, 0L, active5, 0x10000000000000L, active6, 0L, active7, 0L, active8, 0x20L, active9, 0L, active10, 0x80000000000L, active11, 0L, active12, 0L); + case 78: + case 110: + if ((active3 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 250; + jjmatchedPos = 1; + } + else if ((active4 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(1, 305, 89); + else if ((active5 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 373; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x60000L, active1, 0L, active2, 0x1f0000000000000L, active3, 0xf800000000000000L, active4, 0x7fffL, active5, 0xc0000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe000000000000000L, active10, 0x2c0000000000007fL, active11, 0L, active12, 0L); + case 79: + case 111: + if ((active3 & 0x2000000000L) != 0L) + { + jjmatchedKind = 229; + jjmatchedPos = 1; + } + else if ((active5 & 0x100000000L) != 0L) + { + jjmatchedKind = 352; + jjmatchedPos = 1; + } + else if ((active9 & 0x2000000000L) != 0L) + { + jjmatchedKind = 613; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x1800000000000L, active1, 0x1ffffffff8000L, active2, 0xf8000000000L, active3, 0x7804000fc0000L, active4, 0x7c000000100000L, active5, 0x1e000fc000L, active6, 0x3c00000000L, active7, 0x3ff800000L, active8, 0xc0L, active9, 0x4000000000L, active10, 0xc000410000000000L, active11, 0x28L, active12, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0L, active2, 0x200000000000000L, active3, 0L, active4, 0L, active5, 0x700000000000000L, active6, 0L, active7, 0L, active8, 0xf00L, active9, 0L, active10, 0x380L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x400000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xfffffffffffff000L, active9, 0x3L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active5 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 379; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x2000001f00000L, active1, 0x6000000000000L, active2, 0x800100000000000L, active3, 0x1f800f000000L, active4, 0L, active5, 0x7000000000000000L, active6, 0xffc000000000L, active7, 0L, active8, 0L, active9, 0x3ffff8000000000L, active10, 0x20060000000000L, active11, 0L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + else if ((active4 & 0x8000L) != 0L) + { + jjmatchedKind = 271; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x7c000000L, active1, 0L, active2, 0x1000000000000000L, active3, 0L, active4, 0x1fe70000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x1fc00L, active11, 0x40L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x700000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000006000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xffcL, active10, 0x100000000e0000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x800000000L, active1, 0xfff8000000000000L, active2, 0x7L, active3, 0x70000000L, active4, 0L, active5, 0x1f8000300000L, active6, 0x3000000000007L, active7, 0x400000000L, active8, 0L, active9, 0x4000000000ff000L, active10, 0L, active11, 0x180L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L, active1, 0L, active2, 0x2000000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x78L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0xc000000000000000L, active3, 0x3ffL, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(1, 50, 89); + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0xe00000000008L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800000000f00000L, active10, 0L, active11, 0L, active12, 0L); + case 124: + if ((active11 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 754); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_0(0, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 2; + } + switch(curChar) + { + case 43: + if ((active12 & 0x1L) != 0L) + return jjStopAtPos(2, 768); + break; + case 65: + case 97: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_0(2, 8, 89); + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x9bffL, active2, 0x400000800L, active3, 0x18003000000L, active4, 0x30000000000L, active5, 0x1L, active6, 0x72000180000000L, active7, 0x203000000000L, active8, 0x120L, active9, 0x1ff800000003cL, active10, 0x320000000400L, active11, 0x4L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000010000L, active2, 0L, active3, 0L, active4, 0x200200000000L, active5, 0L, active6, 0x1000000000000L, active7, 0L, active8, 0L, active9, 0x200000000703f000L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(2, 26, 89); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0xd01100000000e008L, active3, 0x3800000000000003L, active4, 0x3c000000000000L, active5, 0x400000000080L, active6, 0x80000000000000L, active7, 0x3c00000000000L, active8, 0L, active9, 0xc000000000040000L, active10, 0x4c4000000000000L, active11, 0L, active12, 0L); + case 68: + case 100: + if ((active0 & 0x200L) != 0L) + return jjStartNfaWithStates_0(2, 9, 89); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(2, 17, 89); + else if ((active2 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 181; + jjmatchedPos = 2; + } + else if ((active5 & 0x4000L) != 0L) + { + jjmatchedKind = 334; + jjmatchedPos = 2; + } + else if ((active5 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 371, 89); + else if ((active6 & 0x80L) != 0L) + return jjStartNfaWithStates_0(2, 391, 89); + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x1c0000000000000L, active3, 0x4000000000000000L, active4, 0L, active5, 0x7000000000018000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x800000800000081L, active11, 0L, active12, 0L); + case 69: + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(2, 20, 89); + else if ((active5 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 374, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x2000008000000L, active1, 0x2000000000400L, active2, 0x2002000000000000L, active3, 0x840000400000cL, active4, 0L, active5, 0x100000000000000L, active6, 0xfc000000078L, active7, 0x4000000000000L, active8, 0xe00L, active9, 0x2000030000000L, active10, 0x7c000f800L, active11, 0x80L, active12, 0L); + case 70: + case 102: + if ((active6 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 440; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x2000000000L, active1, 0L, active2, 0x7f0000L, active3, 0L, active4, 0x40000000000L, active5, 0x4000000000000L, active6, 0x600000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000000e0000L, active11, 0L, active12, 0L); + case 71: + case 103: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(2, 36, 89); + else if ((active4 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(2, 290, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x9c000000000L, active1, 0L, active2, 0x800000L, active3, 0L, active4, 0L, active5, 0L, active6, 0xf800000000000000L, active7, 0x20000fL, active8, 0L, active9, 0L, active10, 0x4000000000000000L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000002008000000L, active6, 0L, active7, 0xc000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 73: + case 105: + if ((active6 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(2, 417, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x6000000000000000L, active1, 0L, active2, 0L, active3, 0x8020000000000010L, active4, 0x100001L, active5, 0x10004000000000L, active6, 0x700000000000L, active7, 0x400000L, active8, 0x10L, active9, 0xfc000000000000L, active10, 0x20040000010006L, active11, 0x100L, active12, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0xc00000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L, active12, 0L); + case 76: + case 108: + if ((active0 & 0x1000L) != 0L) + { + jjmatchedKind = 12; + jjmatchedPos = 2; + } + else if ((active8 & 0x1000L) != 0L) + { + jjmatchedKind = 524; + jjmatchedPos = 2; + } + else if ((active10 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(2, 683, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x30000000006000L, active1, 0x1fe0000L, active2, 0x1000000L, active3, 0x800010041400L, active4, 0L, active5, 0x80078010100300L, active6, 0L, active7, 0x18000003800030L, active8, 0xffffffffffffe000L, active9, 0x1L, active10, 0xa200000000700000L, active11, 0x2L, active12, 0L); + case 77: + case 109: + if ((active9 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(2, 595, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x400L, active1, 0x1000001e000000L, active2, 0x8000000000L, active3, 0xc0000000000000L, active4, 0x1000000000000L, active5, 0x180000e00002L, active6, 0L, active7, 0L, active8, 0x46L, active9, 0x400000fc8100000L, active10, 0x2800000000000L, active11, 0x20L, active12, 0L); + case 78: + case 110: + if ((active5 & 0x400L) != 0L) + { + jjmatchedKind = 330; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x8000100000000000L, active1, 0xfffe0000000L, active2, 0xe00002000000L, active3, 0x10000320002000L, active4, 0x80800000002L, active5, 0x201063800L, active6, 0xc000000000000L, active7, 0x8020000400000000L, active8, 0L, active9, 0x1000000000L, active10, 0x401000000060L, active11, 0x8L, active12, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0xc00100000000L, active1, 0x4000000006000L, active2, 0x200100000000000L, active3, 0x1e1408030000L, active4, 0x1fe70004L, active5, 0L, active6, 0x800000000000L, active7, 0xf0000000000L, active8, 0x1L, active9, 0L, active10, 0x10000000000000L, active11, 0L, active12, 0L); + case 80: + case 112: + if ((active3 & 0x20L) != 0L) + { + jjmatchedKind = 197; + jjmatchedPos = 2; + } + else if ((active3 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 240, 89); + else if ((active4 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 312, 89); + return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L, active2, 0x8000004000000L, active3, 0x300000000000040L, active4, 0x8L, active5, 0L, active6, 0L, active7, 0x400000000000c0L, active8, 0L, active9, 0x800004000000000L, active10, 0x110L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active3 & 0x80000L) != 0L) + { + jjmatchedKind = 211; + jjmatchedPos = 2; + } + else if ((active6 & 0x800000L) != 0L) + { + jjmatchedKind = 407; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x40020001e00000L, active1, 0xffe0300000000000L, active2, 0x800000018000007L, active3, 0x70c000L, active4, 0x1000000000L, active5, 0xc00080004L, active6, 0x43f01ff00L, active7, 0x700100000000000L, active8, 0L, active9, 0x702L, active10, 0x100001003f800000L, active11, 0x10L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x10L) != 0L) + { + jjmatchedKind = 4; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x780000030000060L, active1, 0L, active2, 0x40079e0000000L, active3, 0x40000000L, active4, 0x60000000f0L, active5, 0x20000038L, active6, 0x18001e0000L, active7, 0x1800000000001f00L, active8, 0L, active9, 0x1000000000e00000L, active10, 0x200L, active11, 0x1L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(2, 45, 89); + else if ((active2 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(2, 168, 89); + else if ((active3 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(2, 227, 89); + else if ((active4 & 0x100L) != 0L) + { + jjmatchedKind = 264; + jjmatchedPos = 2; + } + else if ((active5 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(2, 356, 89); + else if ((active6 & 0x1L) != 0L) + { + jjmatchedKind = 384; + jjmatchedPos = 2; + } + else if ((active7 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 509; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x1801040e00008880L, active1, 0L, active2, 0x2000001f0L, active3, 0x4000000b80L, active4, 0x3e00008000003e00L, active5, 0x601800006000040L, active6, 0x600006L, active7, 0x40000000000fe000L, active8, 0L, active9, 0L, active10, 0x10000e000000000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000000L, active2, 0x400020000000000L, active3, 0x6000000800000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000000L, active8, 0x80L, active9, 0x300000000000000L, active10, 0L, active11, 0L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1800000000000L, active2, 0L, active3, 0x200000000000L, active4, 0x100000084000L, active5, 0L, active6, 0x40000000L, active7, 0x800100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 87: + case 119: + if ((active2 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(2, 170, 89); + else if ((active5 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(2, 350, 89); + else if ((active7 & 0x40000000L) != 0L) + { + jjmatchedKind = 478; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x40000000000000L, active5, 0L, active6, 0x2000000000L, active7, 0x380000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + if ((active4 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 318; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x80000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(2, 18, 89); + else if ((active2 & 0x200L) != 0L) + { + jjmatchedKind = 137; + jjmatchedPos = 2; + } + else if ((active2 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(2, 171, 89); + else if ((active4 & 0x40000000L) != 0L) + { + jjmatchedKind = 286; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L, active2, 0x400L, active3, 0L, active4, 0x180000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800L, active10, 0L, active11, 0x40L, active12, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + default : + break; + } + return jjStartNfa_0(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_0(1, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 3; + } + switch(curChar) + { + case 45: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 49: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x40000L, active11, 0L); + case 51: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000L, active11, 0L); + case 56: + if ((active10 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(3, 657, 89); + break; + case 95: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0x180000000000000L, active3, 0L, active4, 0x180000000L, active5, 0x2000000000L, active6, 0L, active7, 0x180000000L, active8, 0xffffffffffff0000L, active9, 0x4000000001L, active10, 0x1800000L, active11, 0L); + case 65: + case 97: + if ((active2 & 0x10L) != 0L) + { + jjmatchedKind = 132; + jjmatchedPos = 3; + } + else if ((active4 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(3, 275, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x1802100001e10000L, active1, 0x3800000000000L, active2, 0x1400e08800032020L, active3, 0x12000L, active4, 0x3c000000000000L, active5, 0x8000000L, active6, 0x7f00L, active7, 0x40000000000010L, active8, 0L, active9, 0x2000000000000L, active10, 0x11000000000000a0L, active11, 0L); + case 66: + case 98: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(3, 46, 89); + else if ((active1 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(3, 77, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0x20000000000L, active3, 0x1000000000L, active4, 0L, active5, 0x80000000002L, active6, 0L, active7, 0L, active8, 0L, active9, 0x400000000000000L, active10, 0x2000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x20000000L) != 0L) + { + jjmatchedKind = 157; + jjmatchedPos = 3; + } + else if ((active3 & 0x4L) != 0L) + { + jjmatchedKind = 194; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_0(active0, 0x180000000000000L, active1, 0x400L, active2, 0x2000011c0000000L, active3, 0x21000808L, active4, 0x3e00000000000000L, active5, 0L, active6, 0x81c08f020000L, active7, 0L, active8, 0xf00L, active9, 0x1000000000041000L, active10, 0x4000000L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(3, 239, 89); + else if ((active4 & 0x10000000000L) != 0L) + { + jjmatchedKind = 296; + jjmatchedPos = 3; + } + else if ((active6 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 436; + jjmatchedPos = 3; + } + else if ((active11 & 0x100L) != 0L) + return jjStartNfaWithStates_0(3, 712, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x40000000000000L, active1, 0xe0000000L, active2, 0L, active3, 0L, active4, 0x20000010000L, active5, 0L, active6, 0x20000000000000L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x1000000000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 57, 89); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 115, 89); + else if ((active2 & 0x40L) != 0L) + { + jjmatchedKind = 134; + jjmatchedPos = 3; + } + else if ((active2 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 178, 89); + else if ((active3 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(3, 218, 89); + else if ((active4 & 0x400000000000L) != 0L) + { + jjmatchedKind = 302; + jjmatchedPos = 3; + } + else if ((active5 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(3, 339, 89); + else if ((active5 & 0x400000L) != 0L) + { + jjmatchedKind = 342; + jjmatchedPos = 3; + } + else if ((active5 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(3, 353, 89); + else if ((active7 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(3, 471, 89); + else if ((active8 & 0x8L) != 0L) + return jjStartNfaWithStates_0(3, 515, 89); + else if ((active8 & 0x40L) != 0L) + return jjStartNfaWithStates_0(3, 518, 89); + else if ((active9 & 0x40000000L) != 0L) + { + jjmatchedKind = 606; + jjmatchedPos = 3; + } + else if ((active9 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 632, 89); + else if ((active9 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 635, 89); + else if ((active10 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(3, 686, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x10008820L, active1, 0x10000000000000L, active2, 0xc0000002090c0180L, active3, 0xc0000300200180L, active4, 0x40908200001e32L, active5, 0xb001b00000800000L, active6, 0x600002000000002L, active7, 0x800c800000160L, active8, 0x2000L, active9, 0xf80000100L, active10, 0x800000000000341L, active11, 0L); + case 70: + case 102: + if ((active7 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 500, 89); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0x400000000L, active3, 0L, active4, 0x81800000000L, active5, 0x4L, active6, 0x4000000000000L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x4000000000000400L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 48, 89); + else if ((active2 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 176, 89); + else if ((active6 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(3, 405, 89); + else if ((active10 & 0x2000000000L) != 0L) + { + jjmatchedKind = 677; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_0(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x40L, active6, 0L, active7, 0x200000L, active8, 0L, active9, 0L, active10, 0xc000c000000000L, active11, 0L); + case 73: + case 105: + if ((active10 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(3, 687, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x9c020000480L, active1, 0x1L, active2, 0x10704000L, active3, 0x4000200040000000L, active4, 0x1000000000000L, active5, 0x4600000002008000L, active6, 0x1810000000L, active7, 0x100000000000000L, active8, 0x2L, active9, 0x8000000200L, active10, 0x2008000000000010L, active11, 0L); + case 75: + case 107: + if ((active6 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 435, 89); + else if ((active7 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 498, 89); + else if ((active10 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(3, 671, 89); + else if ((active10 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(3, 680, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x20000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0x4000000000000L, active11, 0L); + case 76: + case 108: + if ((active0 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + } + else if ((active0 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 61; + jjmatchedPos = 3; + } + else if ((active3 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(3, 220, 89); + else if ((active5 & 0x8000000000L) != 0L) + { + jjmatchedKind = 359; + jjmatchedPos = 3; + } + else if ((active6 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 438, 89); + else if ((active11 & 0x2L) != 0L) + return jjStartNfaWithStates_0(3, 705, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x4020800000080000L, active1, 0x7e8000L, active2, 0x8808L, active3, 0x1900000000040043L, active4, 0x40000L, active5, 0x74000000300L, active6, 0x1000000000000L, active7, 0x3003000080L, active8, 0x20L, active9, 0x7000800L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active3 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(3, 219, 89); + else if ((active9 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 630; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_0(active0, 0x140000000L, active1, 0x1e000000L, active2, 0x2000000000000L, active3, 0x402100000L, active4, 0L, active5, 0xc00000000L, active6, 0x100020000000L, active7, 0L, active8, 0L, active9, 0x80000000102000L, active10, 0x10000000000000L, active11, 0L); + case 78: + case 110: + if ((active4 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(3, 276, 89); + else if ((active4 & 0x200000L) != 0L) + { + jjmatchedKind = 277; + jjmatchedPos = 3; + } + else if ((active5 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 376, 89); + else if ((active6 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(3, 416, 89); + else if ((active9 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(3, 604, 89); + else if ((active10 & 0x100000000L) != 0L) + { + jjmatchedKind = 672; + jjmatchedPos = 3; + } + else if ((active11 & 0x4L) != 0L) + return jjStartNfaWithStates_0(3, 706, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x20008000000L, active1, 0x400700000000L, active2, 0L, active3, 0x8018000800000L, active4, 0x1fc00000L, active5, 0L, active6, 0L, active7, 0x400000000L, active8, 0L, active9, 0x201ff0000000000L, active10, 0x200010008L, active11, 0x40L); + case 79: + case 111: + if ((active3 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(3, 230, 89); + else if ((active4 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(3, 269, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x2000006040L, active1, 0x10000L, active2, 0x810000000000000L, active3, 0x210000000020000L, active4, 0x4000L, active5, 0x11000000L, active6, 0x200040000000L, active7, 0xd00000100000L, active8, 0L, active9, 0xe000000000000000L, active10, 0x8000000000000002L, active11, 0L); + case 80: + case 112: + if ((active2 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(3, 172, 89); + else if ((active8 & 0x10L) != 0L) + return jjStartNfaWithStates_0(3, 516, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0x2000000000L, active3, 0L, active4, 0L, active5, 0x200000L, active6, 0x20000000004L, active7, 0xf0000000200L, active8, 0x4L, active9, 0x8000000L, active10, 0x2020000000000L, active11, 0x20L); + case 81: + case 113: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x2L) != 0L) + { + jjmatchedKind = 65; + jjmatchedPos = 3; + } + else if ((active1 & 0x100000000000L) != 0L) + { + jjmatchedKind = 108; + jjmatchedPos = 3; + } + else if ((active3 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 241; + jjmatchedPos = 3; + } + else if ((active6 & 0x8L) != 0L) + { + jjmatchedKind = 387; + jjmatchedPos = 3; + } + else if ((active10 & 0x800L) != 0L) + { + jjmatchedKind = 651; + jjmatchedPos = 3; + } + else if ((active10 & 0x100000000000L) != 0L) + { + jjmatchedKind = 684; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_0(active0, 0x600000000L, active1, 0xffe02000000003fcL, active2, 0x2000000000800001L, active3, 0x2004400000000200L, active4, 0x200000000000L, active5, 0x80L, active6, 0xf802000000000070L, active7, 0x20000000000fL, active8, 0x80L, active9, 0x4L, active10, 0x40020040000f000L, active11, 0x80L); + case 83: + case 115: + if ((active2 & 0x400L) != 0L) + return jjStartNfaWithStates_0(3, 138, 89); + else if ((active7 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(3, 481, 89); + else if ((active7 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 510, 89); + else if ((active9 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(3, 605, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x401f800005800L, active2, 0x2000006L, active3, 0xc410L, active4, 0L, active5, 0x4000000000039L, active6, 0x400000c0000L, active7, 0x1820000000000000L, active8, 0x4000L, active9, 0x3c000L, active10, 0x30000000L, active11, 0x1L); + case 84: + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 58, 89); + else if ((active4 & 0x2000000000L) != 0L) + { + jjmatchedKind = 293; + jjmatchedPos = 3; + } + else if ((active4 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(3, 298, 89); + else if ((active5 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(3, 351, 89); + else if ((active5 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 372, 89); + else if ((active6 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(3, 404, 89); + else if ((active9 & 0x2L) != 0L) + return jjStartNfaWithStates_0(3, 577, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000000L, active1, 0x60000000000L, active2, 0x8004004000000L, active3, 0x8000000000401000L, active4, 0x40000000c1L, active5, 0x20160000L, active6, 0x400418000L, active7, 0x100003c000c00L, active8, 0L, active9, 0xe00038L, active10, 0x20040800000000L, active11, 0x8L); + case 85: + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x1800000L, active2, 0L, active3, 0x1e0000000000L, active4, 0xcL, active5, 0x400004011800L, active6, 0x80000000000000L, active7, 0x80820000000ff000L, active8, 0L, active9, 0x400L, active10, 0x200000000700000L, active11, 0L); + case 86: + case 118: + if ((active6 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(3, 427, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x80000000000L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x2000L, active6, 0x400000000000L, active7, 0x600000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x10L); + case 87: + case 119: + if ((active8 & 0x1L) != 0L) + return jjStartNfaWithStates_0(3, 512, 89); + else if ((active10 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(3, 670, 89); + return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active5 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 375, 89); + return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x20000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000L, active10, 0x8000000L, active11, 0L); + default : + break; + } + return jjStartNfa_0(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(2, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 4; + } + switch(curChar) + { + case 50: + if ((active10 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(4, 659, 89); + break; + case 54: + if ((active10 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(4, 658, 89); + break; + case 95: + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x10000000000004L, active2, 0L, active3, 0x1000000L, active4, 0x80401fc00000L, active5, 0L, active6, 0xf800000000000000L, active7, 0xfL, active8, 0L, active9, 0x80000000000000L, active10, 0x10000000000f000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa5_0(active0, 0x180000000000000L, active1, 0x200063e03f8L, active2, 0x2000008000L, active3, 0x401000100240L, active4, 0x80002000000400c0L, active5, 0x10c00002038L, active6, 0x120000020000L, active7, 0x1000010000004e0L, active8, 0x8000L, active9, 0x1000000000000100L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active5 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(4, 348, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0x20L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1000000L, active8, 0x1f0000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active11 & 0x40L) != 0L) + return jjStartNfaWithStates_0(4, 710, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x2000L, active1, 0L, active2, 0L, active3, 0x4000000000000000L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0x8200080000000L, active8, 0x600080L, active9, 0x200000000000400L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(4, 215, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000L, active1, 0L, active2, 0x10000000002000L, active3, 0xc0000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active1 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(4, 78, 89); + else if ((active2 & 0x8L) != 0L) + return jjStartNfaWithStates_0(4, 131, 89); + else if ((active3 & 0x400L) != 0L) + return jjStartNfaWithStates_0(4, 202, 89); + else if ((active3 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 245, 89); + else if ((active4 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(4, 292, 89); + else if ((active5 & 0x4L) != 0L) + return jjStartNfaWithStates_0(4, 322, 89); + else if ((active5 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(4, 358, 89); + else if ((active6 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 434, 89); + else if ((active7 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(4, 470, 89); + else if ((active7 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(4, 485, 89); + else if ((active7 & 0x10000000000L) != 0L) + { + jjmatchedKind = 488; + jjmatchedPos = 4; + } + else if ((active8 & 0x100L) != 0L) + return jjStartNfaWithStates_0(4, 520, 89); + else if ((active9 & 0x8L) != 0L) + { + jjmatchedKind = 579; + jjmatchedPos = 4; + } + else if ((active9 & 0x800L) != 0L) + return jjStartNfaWithStates_0(4, 587, 89); + else if ((active9 & 0x1000000L) != 0L) + { + jjmatchedKind = 600; + jjmatchedPos = 4; + } + else if ((active10 & 0x400L) != 0L) + return jjStartNfaWithStates_0(4, 650, 89); + else if ((active10 & 0x100000L) != 0L) + { + jjmatchedKind = 660; + jjmatchedPos = 4; + } + else if ((active10 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(4, 674, 89); + else if ((active10 & 0x40000000000L) != 0L) + { + jjmatchedKind = 682; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x20840000000000L, active1, 0xffe0280700408000L, active2, 0x42000002800001L, active3, 0x2100000402001000L, active4, 0x20000L, active5, 0x4080000000202L, active6, 0x84c00f400000L, active7, 0x6800e0000000200L, active8, 0L, active9, 0x6f440d0L, active10, 0x2e0000200600000L, active11, 0L); + case 70: + case 102: + if ((active2 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(4, 155, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0L, active5, 0x8000L, active6, 0L, active7, 0L, active8, 0x4000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active10 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(4, 656, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x20000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x200L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(4, 154, 89); + else if ((active2 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 185, 89); + else if ((active3 & 0x800L) != 0L) + return jjStartNfaWithStates_0(4, 203, 89); + else if ((active4 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 313; + jjmatchedPos = 4; + } + else if ((active5 & 0x20000L) != 0L) + { + jjmatchedKind = 337; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x3c00000000000000L, active5, 0x40000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x804000000L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x4040000700000000L, active1, 0x400f8000000L, active2, 0xc000000000L, active3, 0x8000000000200000L, active4, 0x20000000001L, active5, 0x20020100100L, active6, 0x1410480058000L, active7, 0x182100043c000000L, active8, 0x1fff8000e00L, active9, 0x1000000020L, active10, 0x401000403a000000L, active11, 0x18L); + case 75: + case 107: + if ((active1 & 0x400L) != 0L) + return jjStartNfaWithStates_0(4, 74, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000L, active5, 0L, active6, 0L, active7, 0x100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 76: + case 108: + if ((active1 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(4, 80, 89); + else if ((active3 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(4, 205, 89); + else if ((active4 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(4, 289, 89); + else if ((active4 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(4, 300, 89); + else if ((active4 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 306; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x1800000000000040L, active1, 0L, active2, 0x400020800000800L, active3, 0L, active4, 0x18000000000000L, active5, 0x10000L, active6, 0x30L, active7, 0x100000001000L, active8, 0xe0000000026L, active9, 0x40000c000001000L, active10, 0x1002000000000000L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa5_0(active0, 0x40000000L, active1, 0x1800000L, active2, 0xe00000004000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0x7f00L, active7, 0xc000000000L, active8, 0L, active9, 0x4000000000000000L, active10, 0x20L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x400L) != 0L) + return jjStartNfaWithStates_0(4, 10, 89); + else if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 4; + } + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_0(4, 64, 89); + else if ((active10 & 0x2L) != 0L) + return jjStartNfaWithStates_0(4, 641, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x98000000020L, active1, 0L, active2, 0x400700000L, active3, 0x200000000080L, active4, 0x10L, active5, 0x4000000000000000L, active6, 0L, active7, 0xc00100000000L, active8, 0xf00000000000L, active9, 0x8000000000000200L, active10, 0x2008000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa5_0(active0, 0x20800000080L, active1, 0L, active2, 0x1000000006L, active3, 0x40040000L, active4, 0x10000L, active5, 0x6000000020000c0L, active6, 0x10000000L, active7, 0L, active8, 0L, active9, 0x8000000L, active10, 0x9000000008L, active11, 0L); + case 80: + case 112: + if ((active3 & 0x20000000000L) != 0L) + { + jjmatchedKind = 233; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0xd100000000000000L, active3, 0x1c0000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x800000000L, active8, 0L, active9, 0L, active10, 0x20000800000L, active11, 0L); + case 82: + case 114: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_0(4, 11, 89); + else if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(4, 15, 89); + else if ((active2 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 187, 89); + else if ((active3 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(4, 209, 89); + else if ((active4 & 0x2L) != 0L) + return jjStartNfaWithStates_0(4, 257, 89); + else if ((active4 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 310, 89); + else if ((active5 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(4, 347, 89); + else if ((active5 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 380; + jjmatchedPos = 4; + } + else if ((active6 & 0x2L) != 0L) + return jjStartNfaWithStates_0(4, 385, 89); + else if ((active6 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(4, 421, 89); + else if ((active6 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(4, 429, 89); + else if ((active10 & 0x1L) != 0L) + return jjStartNfaWithStates_0(4, 640, 89); + else if ((active10 & 0x100L) != 0L) + return jjStartNfaWithStates_0(4, 648, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x102010000000L, active1, 0x1800000000000L, active2, 0x3c00c0000L, active3, 0x210000300400100L, active4, 0x8000001c20L, active5, 0xa000500004000000L, active6, 0x680000000000040L, active7, 0x420000000fe800L, active8, 0x1000000000000L, active9, 0L, active10, 0x200L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 114, 89); + else if ((active3 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 242, 89); + else if ((active5 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(4, 341, 89); + else if ((active5 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(4, 343, 89); + else if ((active5 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(4, 362, 89); + else if ((active6 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 437, 89); + else if ((active7 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 511, 89); + else if ((active10 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(4, 685, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0x1800L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1000000L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x1ff0380000000L, active10, 0x1000040L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(4, 110, 89); + else if ((active3 & 0x4000L) != 0L) + { + jjmatchedKind = 206; + jjmatchedPos = 4; + } + else if ((active3 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(4, 208, 89); + else if ((active3 & 0x8000000000L) != 0L) + { + jjmatchedKind = 231; + jjmatchedPos = 4; + } + else if ((active4 & 0x4L) != 0L) + return jjStartNfaWithStates_0(4, 258, 89); + else if ((active4 & 0x8L) != 0L) + return jjStartNfaWithStates_0(4, 259, 89); + else if ((active4 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 304, 89); + else if ((active6 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(4, 414, 89); + else if ((active7 & 0x100L) != 0L) + return jjStartNfaWithStates_0(4, 456, 89); + else if ((active7 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(4, 469, 89); + else if ((active9 & 0x4L) != 0L) + return jjStartNfaWithStates_0(4, 578, 89); + else if ((active9 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 625, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x201f800000000L, active2, 0x1000180L, active3, 0x8010020008010L, active4, 0x20080100000000L, active5, 0x1800000001800L, active6, 0x2001800080000L, active7, 0x10L, active8, 0x7ffc000000004000L, active9, 0x38000L, active10, 0x80L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L, active2, 0x30000L, active3, 0x180000000000000bL, active4, 0x800000000L, active5, 0x1L, active6, 0x20000004L, active7, 0x2000000L, active8, 0L, active9, 0x2000000000002000L, active10, 0x4000000000004L, active11, 0x20L); + case 86: + case 118: + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0x10000000L, active3, 0L, active4, 0L, active5, 0x2000000000L, active6, 0L, active7, 0L, active8, 0x8000000000000000L, active9, 0x1L, active10, 0x10L, active11, 0L); + case 87: + case 119: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(4, 14, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0x1L); + case 88: + case 120: + if ((active10 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 699, 89); + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(4, 19, 89); + else if ((active0 & 0x200000L) != 0L) + { + jjmatchedKind = 21; + jjmatchedPos = 4; + } + else if ((active2 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 179, 89); + else if ((active2 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 189, 89); + else if ((active11 & 0x80L) != 0L) + return jjStartNfaWithStates_0(4, 711, 89); + return jjMoveStringLiteralDfa5_0(active0, 0x1c10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x400000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc00000000L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_0(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(3, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 5; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa6_0(active0, 0x18001c00000L, active1, 0x1800000001000L, active2, 0x2000000L, active3, 0x40002008000L, active4, 0x3000000000000000L, active5, 0x800000000000L, active6, 0L, active7, 0xe0000000000L, active8, 0L, active9, 0x2000000L, active10, 0x2e0000800400000L, active11, 0L); + case 65: + case 97: + if ((active7 & 0x4000000000L) != 0L) + { + jjmatchedKind = 486; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_0(active0, 0x800000002000L, active1, 0L, active2, 0x100000000004020L, active3, 0xc000000300400000L, active4, 0x8800c20001L, active5, 0x4000002004000000L, active6, 0x1800000000008030L, active7, 0x40008001000000L, active8, 0x8000000000804002L, active9, 0x2800f0000001001L, active10, 0x2000005000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa6_0(active0, 0x600000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x100000000L) != 0L) + { + jjmatchedKind = 32; + jjmatchedPos = 5; + } + else if ((active6 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 432, 89); + else if ((active9 & 0x20L) != 0L) + return jjStartNfaWithStates_0(5, 581, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x7004003f8L, active2, 0L, active3, 0x200L, active4, 0L, active5, 0L, active6, 0x2000000000000000L, active7, 0x280L, active8, 0x300000002000L, active9, 0L, active10, 0x10000000000000L, active11, 0x10L); + case 68: + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 53, 89); + else if ((active3 & 0x80L) != 0L) + return jjStartNfaWithStates_0(5, 199, 89); + else if ((active5 & 0x40L) != 0L) + return jjStartNfaWithStates_0(5, 326, 89); + else if ((active6 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(5, 412, 89); + else if ((active7 & 0x400000000000L) != 0L) + { + jjmatchedKind = 494; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_0(active0, 0x180000000000000L, active1, 0x10000000000000L, active2, 0L, active3, 0x1800000000000003L, active4, 0L, active5, 0L, active6, 0x80c000000000L, active7, 0x800000000000L, active8, 0L, active9, 0x8000000000000000L, active10, 0xf000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(5, 37, 89); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 113, 89); + else if ((active2 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(5, 141, 89); + else if ((active2 & 0x100000L) != 0L) + { + jjmatchedKind = 148; + jjmatchedPos = 5; + } + else if ((active2 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(5, 151, 89); + else if ((active2 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(5, 152, 89); + else if ((active2 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(5, 169, 89); + else if ((active2 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 188, 89); + else if ((active3 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 244, 89); + else if ((active5 & 0x800L) != 0L) + { + jjmatchedKind = 331; + jjmatchedPos = 5; + } + else if ((active5 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(5, 336, 89); + else if ((active7 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(5, 468, 89); + else if ((active8 & 0x4L) != 0L) + return jjStartNfaWithStates_0(5, 514, 89); + else if ((active8 & 0x80L) != 0L) + return jjStartNfaWithStates_0(5, 519, 89); + else if ((active9 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 634, 89); + else if ((active10 & 0x4L) != 0L) + return jjStartNfaWithStates_0(5, 642, 89); + else if ((active10 & 0x80L) != 0L) + return jjStartNfaWithStates_0(5, 647, 89); + return jjMoveStringLiteralDfa6_0(active0, 0x40040000000L, active1, 0L, active2, 0x10600000L, active3, 0x10000000000L, active4, 0xc00000081004200L, active5, 0x1001000L, active6, 0x602000000007f00L, active7, 0L, active8, 0x1000001000000L, active9, 0x3c004000040000L, active10, 0x2000020000000020L, active11, 0L); + case 70: + case 102: + if ((active5 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(5, 361, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe00L, active9, 0x300000000000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active3 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(5, 237, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x200000L, active4, 0L, active5, 0x38L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active4 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(5, 299, 89); + else if ((active7 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(5, 493, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x200000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0x20000000800L, active2, 0x10e001c0000180L, active3, 0xc8080020000040L, active4, 0L, active5, 0x2000100000008000L, active6, 0x4000001800000040L, active7, 0x2000000000810L, active8, 0x1c000000070020L, active9, 0x8000008000L, active10, 0x8000000000000L, active11, 0L); + case 76: + case 108: + if ((active3 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 228, 89); + else if ((active6 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(5, 401, 89); + else if ((active7 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(5, 492, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x4L, active2, 0x800030000L, active3, 0L, active4, 0x8000000000000000L, active5, 0xc00002000L, active6, 0x400000000000L, active7, 0x100000000000000L, active8, 0x4480000L, active9, 0x1c00000002000L, active10, 0x1000000000000000L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100L) != 0L) + return jjStartNfaWithStates_0(5, 584, 89); + else if ((active9 & 0x200000L) != 0L) + { + jjmatchedKind = 597; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x2100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x4000000000c00010L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_0(5, 7, 89); + else if ((active1 & 0x800000L) != 0L) + { + jjmatchedKind = 87; + jjmatchedPos = 5; + } + else if ((active2 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(5, 167, 89); + else if ((active3 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(5, 222, 89); + else if ((active5 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 377; + jjmatchedPos = 5; + } + else if ((active7 & 0x2000L) != 0L) + { + jjmatchedKind = 461; + jjmatchedPos = 5; + } + else if ((active10 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(5, 678, 89); + return jjMoveStringLiteralDfa6_0(active0, 0x4040000020000000L, active1, 0xffe0040007000000L, active2, 0x2005000000001L, active3, 0x100L, active4, 0x200000000c0L, active5, 0x400000022000200L, active6, 0x8f040000L, active7, 0x8000043c0fc000L, active8, 0x1fff8000000L, active9, 0x2000001000000000L, active10, 0x400000000a000000L, active11, 0x8L); + case 79: + case 111: + return jjMoveStringLiteralDfa6_0(active0, 0x1800000000000000L, active1, 0L, active2, 0x400000800L, active3, 0L, active4, 0x20000006000000L, active5, 0L, active6, 0x400000000L, active7, 0x1801000880000000L, active8, 0xe0002100000L, active9, 0xc00000000L, active10, 0x30800010L, active11, 0x1L); + case 80: + case 112: + if ((active7 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(5, 473, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000000000L, active10, 0x404000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x2L) != 0L) + { + jjmatchedKind = 129; + jjmatchedPos = 5; + } + else if ((active3 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(5, 204, 89); + else if ((active5 & 0x2L) != 0L) + return jjStartNfaWithStates_0(5, 321, 89); + else if ((active5 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(5, 363, 89); + else if ((active7 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 484, 89); + else if ((active7 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 505; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_0(active0, 0x8000000800000000L, active1, 0x9f800000000L, active2, 0x800000000c8004L, active3, 0x400000000000L, active4, 0xa00000000000L, active5, 0x400000000001L, active6, 0x8000160000400000L, active7, 0x400000000000400L, active8, 0x8000L, active9, 0x8030000L, active10, 0x100000000000000L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(5, 16, 89); + else if ((active2 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 186, 89); + else if ((active3 & 0x10L) != 0L) + return jjStartNfaWithStates_0(5, 196, 89); + else if ((active3 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(5, 236, 89); + else if ((active5 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(5, 338, 89); + else if ((active5 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 368, 89); + else if ((active5 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 383, 89); + else if ((active10 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(5, 661, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x200000008000L, active2, 0L, active3, 0x1000000L, active4, 0xc10L, active5, 0x100180L, active6, 0x80010000000000L, active7, 0x2fL, active8, 0x7fe0000000000000L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_0(5, 5, 89); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(5, 43, 89); + else if ((active1 & 0x8000000L) != 0L) + { + jjmatchedKind = 91; + jjmatchedPos = 5; + } + else if ((active2 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 190; + jjmatchedPos = 5; + } + else if ((active3 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(5, 212, 89); + else if ((active3 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 249, 89); + else if ((active4 & 0x20L) != 0L) + return jjStartNfaWithStates_0(5, 261, 89); + else if ((active5 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(5, 365, 89); + else if ((active5 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 370, 89); + else if ((active6 & 0x4L) != 0L) + return jjStartNfaWithStates_0(5, 386, 89); + else if ((active7 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(5, 460, 89); + else if ((active7 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 499, 89); + else if ((active9 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(5, 590, 89); + else if ((active10 & 0x40L) != 0L) + return jjStartNfaWithStates_0(5, 646, 89); + else if ((active10 & 0x200L) != 0L) + return jjStartNfaWithStates_0(5, 649, 89); + return jjMoveStringLiteralDfa6_0(active0, 0x2000010000000L, active1, 0xf03e0000L, active2, 0x8000002000000000L, active3, 0x400000008L, active4, 0x18000000040000L, active5, 0L, active6, 0x20010000L, active7, 0x20000000000040L, active8, 0L, active9, 0x380100400L, active10, 0L, active11, 0x20L); + case 85: + case 117: + return jjMoveStringLiteralDfa6_0(active0, 0x20000000040L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0x400000000000L, active9, 0L, active10, 0x8000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010001000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0xc0L, active10, 0x200000000L, active11, 0L); + case 87: + case 119: + if ((active4 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(5, 272, 89); + else if ((active10 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 676, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x40000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(5, 44, 89); + return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_0(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(4, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 6; + } + switch(curChar) + { + case 50: + if ((active6 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 447, 89); + break; + case 95: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0xc002c0L, active10, 0x2000000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x40000000400000L, active1, 0xf800000000L, active2, 0x80000000040000L, active3, 0xc0000000000100L, active4, 0x4010001000L, active5, 0x2000000L, active6, 0L, active7, 0x40L, active8, 0x3800000200000L, active9, 0x1c0038c000000L, active10, 0x2000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0x40000000L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x800000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x200000000000L) != 0L) + { + jjmatchedKind = 173; + jjmatchedPos = 6; + } + else if ((active5 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(6, 364, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x800000L, active1, 0x8000L, active2, 0xc06000000800L, active3, 0x440000000000L, active4, 0x40L, active5, 0x1000000L, active6, 0L, active7, 0x80020001000800L, active8, 0x1000000L, active9, 0xf0000000000L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active2 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(6, 149, 89); + else if ((active2 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(6, 156, 89); + else if ((active3 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(6, 232, 89); + else if ((active4 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 314, 89); + else if ((active10 & 0x20L) != 0L) + return jjStartNfaWithStates_0(6, 645, 89); + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x6000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x40L, active7, 0L, active8, 0L, active9, 0x2000000000040000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 6; + } + else if ((active1 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(6, 81, 89); + else if ((active2 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(6, 143, 89); + else if ((active3 & 0x1L) != 0L) + return jjStartNfaWithStates_0(6, 192, 89); + else if ((active3 & 0x8L) != 0L) + return jjStartNfaWithStates_0(6, 195, 89); + else if ((active3 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 251, 89); + else if ((active6 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(6, 413, 89); + else if ((active6 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(6, 425, 89); + else if ((active7 & 0x20L) != 0L) + return jjStartNfaWithStates_0(6, 453, 89); + else if ((active7 & 0x80L) != 0L) + return jjStartNfaWithStates_0(6, 455, 89); + else if ((active7 & 0x4000000L) != 0L) + { + jjmatchedKind = 474; + jjmatchedPos = 6; + } + else if ((active9 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 636, 89); + else if ((active11 & 0x10L) != 0L) + return jjStartNfaWithStates_0(6, 708, 89); + else if ((active11 & 0x20L) != 0L) + return jjStartNfaWithStates_0(6, 709, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x100000000000000L, active1, 0x4L, active2, 0x40000000080000L, active3, 0x2100000001000000L, active4, 0x800000000c00L, active5, 0x4000001081b9L, active6, 0x404000000000L, active7, 0x3803c000L, active8, 0x2000L, active9, 0x10L, active10, 0x110000020000f000L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0x800L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 59; + jjmatchedPos = 6; + } + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 62, 89); + else if ((active4 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(6, 297, 89); + else if ((active5 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(6, 349, 89); + else if ((active6 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(6, 402, 89); + else if ((active6 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(6, 415, 89); + else if ((active7 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(6, 482, 89); + else if ((active10 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(6, 667, 89); + else if ((active10 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 702, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 49, 89); + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x100000000000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa7_0(active0, 0x810000000L, active1, 0x100000e03c0000L, active2, 0x8000000200000000L, active3, 0x1000000000040002L, active4, 0x18000000040010L, active5, 0xc00000000L, active6, 0x80018000010000L, active7, 0x120000800040000L, active8, 0x7fe0000000000e00L, active9, 0xc000000000030000L, active10, 0x8010000000000000L, active11, 0L); + case 76: + case 108: + if ((active2 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(6, 142, 89); + else if ((active3 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(6, 224, 89); + else if ((active3 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 255; + jjmatchedPos = 6; + } + else if ((active4 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(6, 295, 89); + else if ((active5 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(6, 346, 89); + else if ((active6 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(6, 399, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1L, active5, 0x4000812000000000L, active6, 0L, active7, 0x1L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa7_0(active0, 0x21000000L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0xc400000000000L, active9, 0L, active10, 0x1000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(6, 42, 89); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(6, 47, 89); + else if ((active3 & 0x40L) != 0L) + return jjStartNfaWithStates_0(6, 198, 89); + else if ((active3 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(6, 213, 89); + else if ((active3 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 214, 89); + else if ((active6 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 406, 89); + else if ((active6 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(6, 418, 89); + else if ((active7 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 496, 89); + else if ((active7 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 507; + jjmatchedPos = 6; + } + else if ((active10 & 0x8L) != 0L) + return jjStartNfaWithStates_0(6, 643, 89); + else if ((active10 & 0x10000000L) != 0L) + { + jjmatchedKind = 668; + jjmatchedPos = 6; + } + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x20000000000L, active2, 0x10001000000000L, active3, 0x80000000000L, active4, 0x1000000000000000L, active5, 0x2000000000000200L, active6, 0x4600000000000000L, active7, 0x1000040000000000L, active8, 0x100e0000028020L, active9, 0x8c02000000L, active10, 0x80000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1000L, active2, 0x800000000L, active3, 0x20000000L, active4, 0L, active5, 0L, active6, 0x2000001800000000L, active7, 0L, active8, 0x4580000L, active9, 0x300000000000L, active10, 0x400000L, active11, 0L); + case 80: + case 112: + if ((active10 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(6, 663, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L, active1, 0xa00000000000L, active2, 0x180000000L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0x10L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 150, 89); + else if ((active4 & 0x200L) != 0L) + return jjStartNfaWithStates_0(6, 265, 89); + else if ((active4 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(6, 270, 89); + else if ((active4 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(6, 273, 89); + else if ((active4 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 309, 89); + else if ((active6 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 433, 89); + else if ((active8 & 0x2L) != 0L) + return jjStartNfaWithStates_0(6, 513, 89); + else if ((active9 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 626; + jjmatchedPos = 6; + } + else if ((active10 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(6, 666, 89); + else if ((active10 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(6, 681, 89); + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0x100000002000000L, active3, 0x402000000L, active4, 0x2000000000c00000L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x8000000000000000L, active9, 0xb8000000100001L, active10, 0L, active11, 0x1L); + case 83: + case 115: + if ((active4 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 315, 89); + else if ((active5 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(6, 332, 89); + else if ((active5 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 378, 89); + else if ((active7 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(6, 467, 89); + else if ((active7 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(6, 495, 89); + else if ((active10 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 690, 89); + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1000000000000L, active2, 0x400000020L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0L, active9, 0x1000L, active10, 0x20000000000000L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 86, 89); + else if ((active1 & 0x100000000L) != 0L) + { + jjmatchedKind = 96; + jjmatchedPos = 6; + } + else if ((active1 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(6, 107, 89); + else if ((active1 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 117; + jjmatchedPos = 6; + } + else if ((active2 & 0x10000L) != 0L) + { + jjmatchedKind = 144; + jjmatchedPos = 6; + } + else if ((active2 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 177, 89); + else if ((active3 & 0x200L) != 0L) + return jjStartNfaWithStates_0(6, 201, 89); + else if ((active6 & 0x1000000L) != 0L) + { + jjmatchedKind = 408; + jjmatchedPos = 6; + } + else if ((active7 & 0x200L) != 0L) + return jjStartNfaWithStates_0(6, 457, 89); + else if ((active7 & 0x400L) != 0L) + return jjStartNfaWithStates_0(6, 458, 89); + else if ((active8 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(6, 530, 89); + else if ((active9 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(6, 612, 89); + else if ((active10 & 0x10L) != 0L) + return jjStartNfaWithStates_0(6, 644, 89); + else if ((active10 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(6, 679, 89); + return jjMoveStringLiteralDfa7_0(active0, 0x48002040L, active1, 0xffc00006100003f8L, active2, 0x20001L, active3, 0x4008000200000000L, active4, 0x80L, active5, 0L, active6, 0xe007f00L, active7, 0x42000000000000L, active8, 0x1fff8804000L, active9, 0x20000000000a000L, active10, 0x60a000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x600000000L, active1, 0x50000000000L, active2, 0L, active3, 0L, active4, 0x8000000008000000L, active5, 0x2000L, active6, 0x800000000000L, active7, 0x80000000L, active8, 0x2000000L, active9, 0x400L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0x1800040000000000L, active7, 0x10L, active8, 0L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x6L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(6, 63, 89); + else if ((active4 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(6, 301, 89); + else if ((active6 & 0x20L) != 0L) + return jjStartNfaWithStates_0(6, 389, 89); + else if ((active6 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(6, 428, 89); + return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_0(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(5, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 7; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa8_0(active0, 0x1000000000000000L, active1, 0xffc0000006000000L, active2, 0xc00000000001L, active3, 0L, active4, 0L, active5, 0x38L, active6, 0x8000000L, active7, 0x1000000038000000L, active8, 0x7fe0000000000000L, active9, 0x38000000000000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa8_0(active0, 0x10001000000L, active1, 0x1000000000000L, active2, 0x2000800L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x60000000000L, active8, 0x100004020000L, active9, 0x2000200L, active10, 0x80000000000000L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(7, 531, 89); + else if ((active8 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(7, 534, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000040L, active8, 0x8000000002000000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 182, 91); + else if ((active8 & 0x200L) != 0L) + { + jjmatchedKind = 521; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x10000000000L, active2, 0L, active3, 0x1000000L, active4, 0xc00L, active5, 0x180L, active6, 0x600000000000000L, active7, 0x80000000000L, active8, 0xc00L, active9, 0x1L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 56, 89); + else if ((active2 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(7, 147, 89); + else if ((active11 & 0x1L) != 0L) + return jjStartNfaWithStates_0(7, 704, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x40L) != 0L) + return jjStartNfaWithStates_0(7, 6, 89); + else if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(7, 13, 89); + else if ((active1 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(7, 79, 89); + else if ((active1 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(7, 106, 89); + else if ((active2 & 0x20L) != 0L) + return jjStartNfaWithStates_0(7, 133, 89); + else if ((active2 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(7, 158, 89); + else if ((active4 & 0x40L) != 0L) + return jjStartNfaWithStates_0(7, 262, 89); + else if ((active4 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(7, 288, 89); + else if ((active4 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(7, 291, 89); + else if ((active4 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 319, 89); + else if ((active5 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(7, 333, 89); + else if ((active5 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(7, 360, 89); + else if ((active6 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(7, 426, 89); + else if ((active7 & 0x10L) != 0L) + return jjStartNfaWithStates_0(7, 452, 89); + else if ((active7 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 503, 89); + else if ((active8 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(7, 526, 89); + else if ((active8 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(7, 535, 89); + else if ((active8 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 562; + jjmatchedPos = 7; + } + else if ((active9 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 633, 89); + else if ((active10 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 689, 89); + return jjMoveStringLiteralDfa8_0(active0, 0x20000000L, active1, 0x100003f8L, active2, 0x1000000180L, active3, 0x200000000L, active4, 0x2000000008000000L, active5, 0x800000000000L, active6, 0x7f00L, active7, 0L, active8, 0x841fff8000000L, active9, 0x2000004c00000000L, active10, 0x400000000000000L, active11, 0L); + case 70: + case 102: + if ((active10 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(7, 662, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L, active11, 0L); + case 71: + case 103: + if ((active2 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 180, 89); + else if ((active3 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(7, 235, 89); + else if ((active5 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 381, 89); + else if ((active9 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(7, 615, 89); + return jjMoveStringLiteralDfa8_0(active0, 0x400000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000000L, active5, 0L, active6, 0x1800400000000000L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0x100000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(7, 165, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x400000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000L, active1, 0xfe00000800L, active2, 0L, active3, 0L, active4, 0x1000080L, active5, 0x4000000000000200L, active6, 0x6000040L, active7, 0L, active8, 0x1018000L, active9, 0x102000L, active10, 0x20000000L, active11, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active7 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(7, 472, 89); + break; + case 76: + case 108: + if ((active3 & 0x100L) != 0L) + return jjStartNfaWithStates_0(7, 200, 89); + else if ((active4 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(7, 268, 89); + else if ((active5 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(7, 345, 89); + else if ((active8 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 560, 89); + else if ((active10 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 700, 89); + return jjMoveStringLiteralDfa8_0(active0, 0x40020000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010000001L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000100000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0x18000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x384000000L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active3 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(7, 221, 89); + else if ((active6 & 0x800000000L) != 0L) + { + jjmatchedKind = 419; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x1000004L, active2, 0x200000004L, active3, 0x3100000000040002L, active4, 0L, active5, 0x400000000000L, active6, 0x9000000000L, active7, 0x400008880040000L, active8, 0L, active9, 0x30010L, active10, 0x8000000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa8_0(active0, 0x10800000L, active1, 0xa000e03c0000L, active2, 0x8000000000000000L, active3, 0x4000040002000000L, active4, 0x40000L, active5, 0x1000000L, active6, 0x10000090000L, active7, 0x40000000000001L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0x8L); + case 80: + case 112: + if ((active10 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(7, 664, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0x40L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active8 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(7, 533, 89); + else if ((active10 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(7, 673, 89); + return jjMoveStringLiteralDfa8_0(active0, 0x8040000000L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0xc00000L, active5, 0L, active6, 0x800000000000L, active7, 0L, active8, 0x800000000000L, active9, 0x80300008000400L, active10, 0x40000002000000L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(7, 105, 89); + else if ((active2 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(7, 145, 89); + else if ((active5 & 0x1L) != 0L) + return jjStartNfaWithStates_0(7, 320, 89); + else if ((active5 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(7, 335, 89); + else if ((active6 & 0x10L) != 0L) + return jjStartNfaWithStates_0(7, 388, 89); + else if ((active6 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(7, 422, 89); + else if ((active9 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(7, 594, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x10000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1080L, active10, 0x2000000000000000L, active11, 0L); + case 84: + case 116: + if ((active2 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(7, 166, 89); + else if ((active5 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(7, 340, 89); + else if ((active7 & 0x800L) != 0L) + return jjStartNfaWithStates_0(7, 459, 89); + else if ((active8 & 0x20L) != 0L) + return jjStartNfaWithStates_0(7, 517, 89); + return jjMoveStringLiteralDfa8_0(active0, 0x600000000L, active1, 0L, active2, 0x100000580000000L, active3, 0xc0000000000000L, active4, 0x10L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0xc001cf0000400000L, active10, 0x10000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0x2000000000L, active6, 0x2000000000000000L, active7, 0L, active8, 0L, active9, 0x808000L, active10, 0x800000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000000000000L, active7, 0x20000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active2 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(7, 163, 89); + break; + case 88: + case 120: + if ((active7 & 0x2L) != 0L) + return jjStartNfaWithStates_0(7, 449, 89); + break; + case 89: + case 121: + if ((active3 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(7, 226, 89); + else if ((active3 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 243, 89); + else if ((active7 & 0x4L) != 0L) + return jjStartNfaWithStates_0(7, 450, 89); + else if ((active7 & 0x8L) != 0L) + return jjStartNfaWithStates_0(7, 451, 89); + else if ((active7 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 497, 89); + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000000000000L, active9, 0L, active10, 0x228000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa8_0(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0xc00000000L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_0(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(6, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000000000L, active7, 0x3c000L, active8, 0x400L, active9, 0xc00001000L, active10, 0x8000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa9_0(active0, 0x8800000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0xc00080L, active5, 0L, active6, 0L, active7, 0x500008000000000L, active8, 0L, active9, 0x80000000000080L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(8, 557, 89); + break; + case 67: + case 99: + if ((active9 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(8, 596, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x40000000000000L, active2, 0x1000000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0x400000000000L, active6, 0L, active7, 0x8000000L, active8, 0x800000000000L, active9, 0x8000000000000L, active10, 0x800000000L, active11, 0L); + case 68: + case 100: + if ((active1 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(8, 92, 89); + else if ((active3 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(8, 225, 89); + else if ((active9 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 637, 89); + else if ((active10 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 698, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x180000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000L) != 0L) + { + jjmatchedKind = 33; + jjmatchedPos = 8; + } + else if ((active2 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 183, 89); + else if ((active3 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 246; + jjmatchedPos = 8; + } + else if ((active4 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 307; + jjmatchedPos = 8; + } + else if ((active5 & 0x400000000L) != 0L) + { + jjmatchedKind = 354; + jjmatchedPos = 8; + } + else if ((active5 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(8, 357, 89); + else if ((active6 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(8, 431, 89); + else if ((active6 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 439, 89); + else if ((active7 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 501, 89); + else if ((active9 & 0x400L) != 0L) + return jjStartNfaWithStates_0(8, 586, 89); + else if ((active9 & 0x400000000000L) != 0L) + { + jjmatchedKind = 622; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_0(active0, 0x400000000L, active1, 0x800L, active2, 0L, active3, 0x80000000000000L, active4, 0x10800086000000L, active5, 0x800000000L, active6, 0x4200400000000000L, active7, 0x100000000L, active8, 0x100000L, active9, 0x800000000000L, active10, 0L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(8, 22, 89); + else if ((active3 & 0x2L) != 0L) + return jjStartNfaWithStates_0(8, 193, 89); + else if ((active3 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(8, 210, 89); + else if ((active3 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 252, 89); + else if ((active6 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(8, 423, 89); + else if ((active7 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(8, 466, 89); + else if ((active9 & 0x10000L) != 0L) + { + jjmatchedKind = 592; + jjmatchedPos = 8; + } + else if ((active10 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 703, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x4L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000L, active9, 0x20200L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0x80000000000000L, active9, 0x1L, active10, 0L, active11, 0L); + case 73: + case 105: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(8, 41, 89); + return jjMoveStringLiteralDfa9_0(active0, 0x40000040000000L, active1, 0x1000L, active2, 0x100000680000000L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000000L, active9, 0x80010f0000400000L, active10, 0x210000000000f000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0x8000L, active4, 0L, active5, 0x8L, active6, 0x6000000L, active7, 0x40L, active8, 0x2000002000000L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100000000000L) != 0L) + { + jjmatchedKind = 620; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0L, active7, 0x40000000000L, active8, 0x700000001000000L, active9, 0x200002000000L, active10, 0x80000000000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(8, 28, 89); + else if ((active1 & 0x40000L) != 0L) + { + jjmatchedKind = 82; + jjmatchedPos = 8; + } + else if ((active1 & 0x20000000L) != 0L) + { + jjmatchedKind = 93; + jjmatchedPos = 8; + } + else if ((active2 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 191, 89); + else if ((active4 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(8, 274, 89); + else if ((active6 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(8, 400, 89); + else if ((active6 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(8, 424, 89); + return jjMoveStringLiteralDfa9_0(active0, 0x1000000020800000L, active1, 0x20f8c0380000L, active2, 0x2000000L, active3, 0x40000000000L, active4, 0L, active5, 0x800001000000L, active6, 0x2000000000000040L, active7, 0x10000000L, active8, 0x18000L, active9, 0x10000000000000L, active10, 0x20000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x600000000L, active2, 0x100000000L, active3, 0x1000000L, active4, 0L, active5, 0x190L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40L, active10, 0x40000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(8, 111, 89); + else if ((active9 & 0x80000000L) != 0L) + { + jjmatchedKind = 607; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x200000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1L, active8, 0L, active9, 0x304000000L, active10, 0x200000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 8; + } + else if ((active3 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 254, 89); + else if ((active6 & 0x100L) != 0L) + { + jjmatchedKind = 392; + jjmatchedPos = 8; + } + else if ((active7 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 502, 89); + else if ((active8 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(8, 556, 89); + return jjMoveStringLiteralDfa9_0(active0, 0x10000000000L, active1, 0xc000000000003f0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0x8007e00L, active7, 0L, active8, 0x41fff0020000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0x1008000000000000L, active9, 0x20000000802000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 116, 89); + else if ((active3 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 253, 89); + else if ((active4 & 0x400L) != 0L) + { + jjmatchedKind = 266; + jjmatchedPos = 8; + } + else if ((active7 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(8, 479, 89); + else if ((active7 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(8, 483, 89); + else if ((active8 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(8, 538, 89); + else if ((active9 & 0x10L) != 0L) + return jjStartNfaWithStates_0(8, 580, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0xe000010000000000L, active2, 0x800L, active3, 0x100000000000000L, active4, 0x800L, active5, 0x4000000000000020L, active6, 0L, active7, 0x20000000000L, active8, 0x2800L, active9, 0x4000000000008000L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x4010000000L, active5, 0x200L, active6, 0x80000L, active7, 0x1000000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa9_0(active0, 0x8000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active3 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(8, 217, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active6 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 443, 89); + return jjMoveStringLiteralDfa9_0(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active3 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(8, 238, 89); + else if ((active4 & 0x1L) != 0L) + return jjStartNfaWithStates_0(8, 256, 89); + else if ((active6 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 444, 89); + else if ((active9 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(8, 603, 89); + else if ((active10 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(8, 665, 89); + else if ((active10 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 692, 89); + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4000000000000000L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_0(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(7, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 9; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa10_0(active0, 0x1000000L, active1, 0x803800f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7e00L, active7, 0L, active8, 0L, active9, 0x804000020000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa10_0(active0, 0x1000000000000000L, active1, 0x2c0000040000000L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x8000000L, active7, 0x20018000000L, active8, 0x200e0001100000L, active9, 0x18000100000001L, active10, 0L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000080L, active5, 0L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(9, 30, 89); + return jjMoveStringLiteralDfa10_0(active0, 0x800000L, active1, 0x1000000000000000L, active2, 0x400000000L, active3, 0x40000000000L, active4, 0x6000000L, active5, 0x10L, active6, 0L, active7, 0x20004000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L, active11, 0L); + case 68: + case 100: + if ((active5 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(9, 344, 89); + else if ((active5 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(9, 355, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x200000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(9, 27, 89); + else if ((active2 & 0x800L) != 0L) + return jjStartNfaWithStates_0(9, 139, 89); + else if ((active2 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(9, 146, 89); + else if ((active4 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(9, 284, 89); + else if ((active4 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(9, 294, 89); + else if ((active7 & 0x1L) != 0L) + return jjStartNfaWithStates_0(9, 448, 89); + else if ((active7 & 0x40L) != 0L) + return jjStartNfaWithStates_0(9, 454, 89); + else if ((active7 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(9, 490, 89); + else if ((active8 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(9, 537, 89); + else if ((active9 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(9, 591, 89); + else if ((active9 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(9, 601, 89); + else if ((active10 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 695, 89); + else if ((active10 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 697, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000028L, active6, 0x6000000L, active7, 0x80000000000L, active8, 0x7000000008000000L, active9, 0x4000000000802000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active6 & 0x40L) != 0L) + return jjStartNfaWithStates_0(9, 390, 89); + else if ((active8 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(9, 527, 89); + else if ((active9 & 0x200L) != 0L) + return jjStartNfaWithStates_0(9, 585, 89); + else if ((active10 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(9, 669, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x800000000000L, active6, 0x80000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0x400000000L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x6000000000000100L, active2, 0x180L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0L, active7, 0L, active8, 0x302400000002000L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active2 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(9, 153, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000800000000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x80000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active5 & 0x200L) != 0L) + return jjStartNfaWithStates_0(9, 329, 89); + return jjMoveStringLiteralDfa10_0(active0, 0x8000000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0x800400080L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active1 & 0x200000000L) != 0L) + { + jjmatchedKind = 97; + jjmatchedPos = 9; + } + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x400000000L, active2, 0L, active3, 0x1000000L, active4, 0L, active5, 0x180L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000400L, active9, 0L, active10, 0xf000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0xc00010000000000L, active2, 0x80000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x480000000000000L, active9, 0x80010f0000001000L, active10, 0x100000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 112, 89); + else if ((active9 & 0x40L) != 0L) + return jjStartNfaWithStates_0(9, 582, 89); + break; + case 82: + case 114: + if ((active1 & 0x800L) != 0L) + return jjStartNfaWithStates_0(9, 75, 89); + else if ((active2 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(9, 160, 89); + else if ((active4 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(9, 287, 89); + else if ((active7 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(9, 480, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000001000000000L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(9, 34, 89); + else if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_0(9, 73, 89); + else if ((active6 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(9, 430, 89); + else if ((active6 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 441, 89); + else if ((active9 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(9, 621, 89); + else if ((active11 & 0x8L) != 0L) + return jjStartNfaWithStates_0(9, 707, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0x200000001L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0L, active7, 0x1000000000020000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(9, 29, 89); + else if ((active1 & 0x800000000L) != 0L) + { + jjmatchedKind = 99; + jjmatchedPos = 9; + } + else if ((active2 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(9, 164, 89); + else if ((active6 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 445, 89); + else if ((active8 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(9, 528, 89); + return jjMoveStringLiteralDfa10_0(active0, 0x40010800000000L, active1, 0xf000000004L, active2, 0x100000000000000L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1fff0000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active4 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(9, 303, 89); + break; + case 89: + case 121: + if ((active4 & 0x400000L) != 0L) + { + jjmatchedKind = 278; + jjmatchedPos = 9; + } + else if ((active4 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(9, 283, 89); + else if ((active5 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 382, 89); + else if ((active8 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(9, 529, 89); + else if ((active9 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(9, 631, 89); + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000000000000000L, active11, 0L); + default : + break; + } + return jjStartNfa_0(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_0(8, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 10; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x7400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x6000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa11_0(active0, 0x800000L, active1, 0x8000000000000000L, active2, 0L, active3, 0x40000000000L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0xc84881fff0000400L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active8 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(10, 558, 89); + return jjMoveStringLiteralDfa11_0(active0, 0x1000000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0x10000L, active8, 0x1100000000000000L, active9, 0x4000000000L, active10, 0L); + case 68: + case 100: + if ((active3 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(10, 216, 89); + else if ((active5 & 0x80L) != 0L) + return jjStartNfaWithStates_0(10, 327, 89); + else if ((active5 & 0x100L) != 0L) + return jjStartNfaWithStates_0(10, 328, 89); + else if ((active9 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 638, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x100000000L, active10, 0L); + case 69: + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(10, 39, 89); + else if ((active1 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(10, 88, 89); + else if ((active2 & 0x4L) != 0L) + return jjStartNfaWithStates_0(10, 130, 89); + else if ((active3 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(10, 207, 89); + else if ((active4 & 0x10L) != 0L) + return jjStartNfaWithStates_0(10, 260, 89); + else if ((active7 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(10, 487, 89); + else if ((active7 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 506, 89); + else if ((active9 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(10, 598, 89); + else if ((active9 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(10, 602, 89); + else if ((active10 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 701, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0x1000000000L, active7, 0x1000000000008000L, active8, 0x2000000000000000L, active9, 0L, active10, 0x800080000f000L); + case 70: + case 102: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active6 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 442, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_0(10, 66, 89); + else if ((active6 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(10, 403, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L); + case 73: + case 105: + return jjMoveStringLiteralDfa11_0(active0, 0x10800000000L, active1, 0x200000001000L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xa00000000L, active10, 0L); + case 76: + case 108: + if ((active1 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(10, 94, 89); + else if ((active8 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(10, 536, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x400000000000010L, active2, 0L, active3, 0L, active4, 0x80L, active5, 0L, active6, 0L, active7, 0x100020000000000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa11_0(active0, 0x1000000000000000L, active1, 0x6000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x80010000000L, active8, 0L, active9, 0x10000000000000L, active10, 0L); + case 78: + case 110: + if ((active2 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(10, 159, 89); + else if ((active8 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(10, 532, 89); + else if ((active9 & 0x10000000000L) != 0L) + { + jjmatchedKind = 616; + jjmatchedPos = 10; + } + else if ((active9 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 624, 89); + else if ((active10 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 696, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x86100000L, active2, 0xc00000000180L, active3, 0L, active4, 0L, active5, 0x8L, active6, 0x8000400L, active7, 0L, active8, 0x602000000000000L, active9, 0x80000e0000000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x2000L, active9, 0x400000000L, active10, 0L); + case 80: + case 112: + if ((active9 & 0x80L) != 0L) + return jjStartNfaWithStates_0(10, 583, 89); + else if ((active10 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 694, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active1 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(10, 104, 89); + else if ((active8 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(10, 539, 89); + else if ((active9 & 0x1L) != 0L) + return jjStartNfaWithStates_0(10, 576, 89); + else if ((active9 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(10, 599, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0x800000021000L, active10, 0L); + case 83: + case 115: + if ((active1 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(10, 103, 89); + else if ((active2 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(10, 162, 89); + else if ((active4 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(10, 280, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x2001e0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active4 & 0x2000000L) != 0L) + { + jjmatchedKind = 281; + jjmatchedPos = 10; + } + else if ((active8 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 564, 89); + else if ((active9 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(10, 589, 89); + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x2c0000000000000L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0x10000004000000L, active5, 0x800000000010L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000000L, active9, 0L, active10, 0L); + case 87: + case 119: + if ((active1 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 123, 89); + break; + case 88: + case 120: + return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x20L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 54, 89); + else if ((active3 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 247, 89); + else if ((active8 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(10, 565, 89); + break; + default : + break; + } + return jjStartNfa_0(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(9, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 11; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active7 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(11, 491, 89); + return jjMoveStringLiteralDfa12_0(active0, 0x1000000L, active1, 0x140000000180000L, active2, 0L, active3, 0L, active4, 0x10000004000000L, active5, 0L, active6, 0x400L, active7, 0x8000000L, active8, 0L, active9, 0x8008000000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x1006200000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x40040000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(11, 608, 89); + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 69: + case 101: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 60, 89); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 119, 89); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 122, 89); + else if ((active1 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 125; + jjmatchedPos = 11; + } + else if ((active4 & 0x80L) != 0L) + return jjStartNfaWithStates_0(11, 263, 89); + else if ((active7 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(11, 476, 89); + else if ((active7 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 504, 89); + else if ((active8 & 0x800L) != 0L) + return jjStartNfaWithStates_0(11, 523, 89); + else if ((active9 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 628, 89); + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x50000000000000f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0x4000000000000000L, active7, 0x20000000L, active8, 0L, active9, 0x20800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0x8L, active6, 0x1000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 121, 89); + else if ((active5 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(11, 367, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000L, active10, 0L); + case 75: + case 107: + if ((active6 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(11, 411, 89); + else if ((active8 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 573, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0x1fff0000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000400L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(11, 76, 89); + else if ((active4 & 0x800L) != 0L) + return jjStartNfaWithStates_0(11, 267, 89); + else if ((active8 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(11, 525, 89); + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x8000202400000000L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0x80000000000L, active9, 0x800000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa12_0(active0, 0x800000000L, active1, 0L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x20000000000L, active8, 0x1000000000000000L, active9, 0x4000000000L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active2 & 0x1L) != 0L) + return jjStartNfaWithStates_0(11, 128, 89); + else if ((active4 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 316, 89); + else if ((active7 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 508, 89); + else if ((active8 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(11, 559, 89); + else if ((active8 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 567, 89); + else if ((active8 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 574, 89); + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x8900000000000000L, active9, 0L, active10, 0x20000000000000L); + case 83: + case 115: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe0000000000L, active10, 0L); + case 84: + case 116: + if ((active3 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(11, 234, 89); + else if ((active5 & 0x20L) != 0L) + return jjStartNfaWithStates_0(11, 325, 89); + else if ((active8 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 561, 89); + else if ((active10 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(11, 675, 89); + return jjMoveStringLiteralDfa12_0(active0, 0x10000800000L, active1, 0x100L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x400000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x200000000000000L, active9, 0x400000000L, active10, 0L); + case 89: + case 121: + if ((active10 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 691, 89); + break; + default : + break; + } + return jjStartNfa_0(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(10, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 12; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa13_0(active0, 0x800000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4001fff0000000L, active9, 0xe0000000000L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x3400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active2 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(12, 161, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0xa00L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x400L) != 0L) + return jjStartNfaWithStates_0(12, 522, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000007000L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + if ((active9 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(12, 609, 89); + break; + case 71: + case 103: + if ((active1 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(12, 109, 89); + else if ((active4 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(12, 279, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000000L, active5, 0L, active6, 0L, active7, 0x20000008000L, active8, 0L, active9, 0x800000021000L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(12, 570, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa13_0(active0, 0x10000000000L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 76: + case 108: + if ((active9 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(12, 639, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x1000000080100000L, active2, 0L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0x400L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(12, 35, 89); + else if ((active2 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(12, 184, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x100000000000000L, active9, 0L, active10, 0x20000000000000L); + case 80: + case 112: + if ((active8 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(12, 563, 89); + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active9 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(12, 610, 89); + return jjMoveStringLiteralDfa13_0(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0xc000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x60800e0L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0x18L, active6, 0L, active7, 0L, active8, 0xa00000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x4800000000L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(12, 575, 89); + break; + default : + break; + } + return jjStartNfa_0(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa13_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(11, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 13; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0xe0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 124, 89); + else if ((active7 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(13, 477, 89); + else if ((active9 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 629, 89); + return jjMoveStringLiteralDfa14_0(active0, 0x800000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0x20000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 572, 89); + return jjMoveStringLiteralDfa14_0(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xf0000000L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(13, 84, 89); + else if ((active6 & 0x200L) != 0L) + return jjStartNfaWithStates_0(13, 393, 89); + else if ((active6 & 0x400L) != 0L) + return jjStartNfaWithStates_0(13, 394, 89); + else if ((active8 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 569, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0x800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active4 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(13, 282, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x8L) != 0L) + return jjStartNfaWithStates_0(13, 323, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80700000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x1000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x2400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active3 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 248, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x20000000000L, active9, 0x4000000000L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa14_0(active0, 0x10000000000L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 80: + case 112: + if ((active4 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 308, 89); + break; + case 82: + case 114: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 83: + case 115: + if ((active7 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(13, 489, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(13, 446, 89); + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x38000L, active8, 0L, active9, 0x800000000L, active10, 0xf000L); + case 88: + case 120: + if ((active6 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(13, 420, 89); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_0(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa14_0(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(12, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 14; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0xa00f0000000L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active6 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(14, 410, 89); + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x20L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(14, 98, 89); + else if ((active1 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(14, 101, 89); + else if ((active4 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(14, 317, 89); + else if ((active9 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(14, 611, 89); + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x4080000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x14001c000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(14, 118, 89); + else if ((active7 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(14, 475, 89); + else if ((active9 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(14, 627, 89); + return jjMoveStringLiteralDfa15_0(active0, 0x800000L, active1, 0L, active2, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active7 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(14, 463, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa15_0(active0, 0x1000000L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x80000L, active2, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x200000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(14, 40, 89); + else if ((active9 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(14, 588, 89); + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x40L, active2, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x8000000006000000L, active2, 0xc00000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2700000000L, active9, 0xc0000000000L, active10, 0L); + case 82: + case 114: + if ((active8 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(14, 554, 89); + else if ((active8 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(14, 571, 89); + break; + case 83: + case 115: + if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_0(14, 72, 89); + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x80L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(14, 409, 89); + else if ((active9 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(14, 614, 89); + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x100000000000010L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0L, active2, 0x180L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active9 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(14, 593, 89); + else if ((active9 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(14, 623, 89); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + default : + break; + } + return jjStartNfa_0(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa15_0(long old0, long active0, long old1, long active1, long old2, long active2, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(13, old0, old1, old2, 0L, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 15; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(15, 85, 89); + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x60L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0x400000000010L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(15, 23, 89); + break; + case 72: + case 104: + if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_0(15, 68, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x4000004000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 15; + } + else if ((active2 & 0x400000000000L) != 0L) + { + jjmatchedKind = 174; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_0(active0, 0x1000000L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x80000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 82: + case 114: + if ((active1 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(15, 95, 89); + else if ((active8 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(15, 555, 89); + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x700000000L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x10000000L) != 0L) + { + jjmatchedKind = 540; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + default : + break; + } + return jjStartNfa_0(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa16_0(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(14, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 16; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(16, 102, 89); + return jjMoveStringLiteralDfa17_0(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 69: + case 101: + if ((active7 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(16, 465, 89); + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0xf000L); + case 71: + case 103: + if ((active1 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(16, 83, 89); + break; + case 72: + case 104: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x8000000000000040L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + if ((active1 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(16, 126, 89); + break; + case 82: + case 114: + if ((active8 & 0x100000000L) != 0L) + { + jjmatchedKind = 544; + jjmatchedPos = 16; + } + else if ((active8 & 0x8000000000L) != 0L) + { + jjmatchedKind = 551; + jjmatchedPos = 16; + } + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x100000000000020L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active5 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(16, 366, 89); + break; + case 89: + case 121: + if ((active8 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(16, 553, 89); + break; + default : + break; + } + return jjStartNfa_0(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa17_0(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(15, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x8000000000000000L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_0(17, 70, 89); + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(17, 100, 89); + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(17, 549, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa18_0(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 82: + case 114: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18e0000000L, active9, 0L, active10, 0x20000000000000L); + case 86: + case 118: + return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_0(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa18_0(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(16, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 18; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0x80L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x3000L); + case 68: + case 100: + if ((active8 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(18, 550, 89); + else if ((active8 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(18, 566, 89); + else if ((active8 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(18, 568, 89); + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x800000000L) != 0L) + { + jjmatchedKind = 547; + jjmatchedPos = 18; + } + else if ((active9 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(18, 617, 89); + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa19_0(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4000L); + case 79: + case 111: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0x100L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 84: + case 116: + return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0x4000L, active8, 0x10600000000L, active9, 0x40000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_0(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa19_0(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(17, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 19; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10e0000000L, active9, 0x80000000000L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_0(19, 71, 89); + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x5000L); + case 67: + case 99: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x1000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 68: + case 100: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x10L) != 0L) + return jjStartNfaWithStates_0(19, 324, 89); + break; + case 78: + case 110: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0x2000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x20L, active2, 0x80L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0x20000000002000L); + case 82: + case 114: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x8000000000000000L, active2, 0x100L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa20_0(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 89: + case 121: + if ((active7 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(19, 462, 89); + break; + default : + break; + } + return jjStartNfa_0(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa20_0(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(18, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); + return 20; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0x3000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0x80L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000L); + case 69: + case 101: + if ((active1 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(20, 90, 89); + else if ((active2 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(20, 175, 89); + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0x100L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_0(20, 69, 89); + break; + case 72: + case 104: + if ((active7 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(20, 464, 89); + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x20000000L, active9, 0L, active10, 0x8000L); + case 77: + case 109: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x40000000L, active9, 0L, active10, 0x4000L); + case 78: + case 110: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x100000000000000L, active2, 0L, active6, 0x800L, active7, 0L, active8, 0x80000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0x1000L); + case 89: + case 121: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(20, 24, 89); + break; + default : + break; + } + return jjStartNfa_0(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa21_0(long old0, long active0, long old1, long active1, long old2, long active2, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(19, old0, old1, old2, 0L, 0L, 0L, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 21; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 65: + case 97: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0x80000000000L, active10, 0x1000L); + case 67: + case 99: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(21, 618, 89); + break; + case 69: + case 101: + if ((active2 & 0x80L) != 0L) + return jjStartNfaWithStates_0(21, 135, 89); + else if ((active10 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(21, 653, 89); + else if ((active10 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(21, 654, 89); + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x8000L); + case 70: + case 102: + return jjMoveStringLiteralDfa22_0(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0x800L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0x2000L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x1020000000L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa22_0(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa22_0(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_0(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa22_0(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(20, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 22; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active6 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(22, 397, 89); + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x200000000L, active9, 0L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x1000L); + case 77: + case 109: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000008000L); + case 78: + case 110: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa23_0(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0x10000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa23_0(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa23_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x20000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_0(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa23_0(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(21, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 23; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa24_0(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active10 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(23, 655, 89); + break; + case 67: + case 99: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 75: + case 107: + if ((active9 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(23, 619, 89); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x20000000001000L); + case 82: + case 114: + if ((active8 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(23, 541, 89); + return jjMoveStringLiteralDfa24_0(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa24_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_0(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa24_0(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_0(22, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 24; + } + switch(curChar) + { + case 65: + case 97: + if ((active6 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(24, 398, 89); + break; + case 68: + case 100: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active10, 0x20000000000000L); + case 69: + case 101: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa25_0(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 71: + case 103: + if ((active10 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(24, 652, 89); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa25_0(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0x1800L, active8, 0x400000000L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x10040000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa25_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_0(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa25_0(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_0(23, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 25; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa26_0(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa26_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(25, 543, 89); + break; + case 69: + case 101: + if ((active8 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(25, 542, 89); + else if ((active10 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(25, 693, 89); + break; + case 71: + case 103: + if ((active6 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(25, 396, 89); + break; + case 72: + case 104: + if ((active8 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(25, 552, 89); + break; + case 78: + case 110: + if ((active6 & 0x800L) != 0L) + return jjStartNfaWithStates_0(25, 395, 89); + return jjMoveStringLiteralDfa26_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa26_0(active1, 0x8000000000000000L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa26_0(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_0(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa26_0(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_0(24, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 26; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(26, 546, 89); + break; + case 69: + case 101: + if ((active8 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(26, 545, 89); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa27_0(active1, 0x100000000000000L, active2, 0L, active8, 0L); + case 78: + case 110: + if ((active2 & 0x100L) != 0L) + return jjStartNfaWithStates_0(26, 136, 89); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa27_0(active1, 0L, active2, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa27_0(active1, 0x8000000000000000L, active2, 0L, active8, 0L); + default : + break; + } + return jjStartNfa_0(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa27_0(long old1, long active1, long old2, long active2, long old8, long active8) +{ + if (((active1 &= old1) | (active2 &= old2) | (active8 &= old8)) == 0L) + return jjStartNfa_0(25, 0L, old1, old2, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 27; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa28_0(active1, 0x8000000000000000L, active8, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa28_0(active1, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa28_0(active1, 0x100000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_0(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa28_0(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_0(26, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 28; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(28, 548, 89); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa29_0(active1, 0x100000000000000L, active8, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa29_0(active1, 0x8000000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_0(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa29_0(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_0(27, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 29; + } + switch(curChar) + { + case 85: + case 117: + return jjMoveStringLiteralDfa30_0(active1, 0x100000000000000L); + case 89: + case 121: + return jjMoveStringLiteralDfa30_0(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_0(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa30_0(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_0(28, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 30; + } + switch(curChar) + { + case 80: + case 112: + if ((active1 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(30, 120, 89); + return jjMoveStringLiteralDfa31_0(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_0(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa31_0(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_0(29, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 31; + } + switch(curChar) + { + case 69: + case 101: + if ((active1 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(31, 127, 89); + break; + default : + break; + } + return jjStartNfa_0(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveNfa_0(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 86; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 86: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(3, 5); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 88: + case 22: + if ((0xffffffffffffdbffL & l) != 0L) + jjCheckNAddStates(6, 8); + break; + case 84: + if (curChar == 47) + { + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + } + else if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 82; + break; + case 58: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 59; + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 55: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + else if (curChar == 39) + { + if (kind > 720) + kind = 720; + } + if ((0xfc00f7faffffc9ffL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 87: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 91: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if (curChar == 36) + jjCheckNAdd(31); + break; + case 90: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 1: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(15, 17); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 0: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 47) + jjAddStates(18, 19); + else if (curChar == 39) + jjCheckNAddStates(20, 23); + else if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + else if (curChar == 7) + { + if (kind > 786) + kind = 786; + } + else if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + } + else if (curChar == 36) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 2: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(15, 17); + break; + case 3: + if (curChar == 39) + jjCheckNAddStates(15, 17); + break; + case 4: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 3; + break; + case 5: + if (curChar == 39 && kind > 719) + kind = 719; + break; + case 7: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7ff600000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 9: + case 11: + if (curChar == 39) + jjCheckNAddStates(3, 5); + break; + case 10: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 12: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 11; + break; + case 13: + if (curChar == 39 && kind > 721) + kind = 721; + break; + case 15: + if (curChar != 45) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 16: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 17: + if ((0x2400L & l) != 0L && kind > 772) + kind = 772; + break; + case 18: + if (curChar == 10 && kind > 772) + kind = 772; + break; + case 19: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 18; + break; + case 20: + if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + break; + case 26: + if (curChar != 36) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 29: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 30: + if (curChar == 36) + jjCheckNAdd(31); + break; + case 31: + if (curChar != 36) + break; + if (kind > 782) + kind = 782; + jjCheckNAddTwoStates(31, 32); + break; + case 32: + if (curChar == 36) + jjCheckNAdd(33); + break; + case 33: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjCheckNAdd(33); + break; + case 34: + if (curChar == 7 && kind > 786) + kind = 786; + break; + case 35: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + break; + case 36: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAdd(36); + break; + case 37: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(37, 38); + break; + case 39: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(40); + break; + case 40: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 714) + kind = 714; + jjCheckNAdd(40); + break; + case 41: + if (curChar == 46) + jjCheckNAddTwoStates(42, 38); + break; + case 42: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(42, 38); + break; + case 43: + if (curChar != 46) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 44: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 45: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAddStates(31, 33); + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(34, 37); + break; + case 47: + if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + break; + case 48: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 49: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + break; + case 50: + if (curChar == 39) + jjCheckNAddStates(20, 23); + break; + case 51: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 52: + if (curChar == 39) + jjCheckNAddStates(12, 14); + break; + case 53: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 54: + if (curChar == 39 && kind > 720) + kind = 720; + break; + case 56: + if (curChar == 39 && kind > 726) + kind = 726; + break; + case 59: + case 61: + if (curChar == 39) + jjCheckNAddStates(38, 40); + break; + case 60: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(38, 40); + break; + case 62: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 61; + break; + case 63: + if (curChar == 39 && kind > 722) + kind = 722; + break; + case 64: + if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + break; + case 65: + if (curChar == 34) + jjCheckNAddTwoStates(66, 68); + break; + case 66: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(41, 43); + break; + case 67: + if (curChar == 34) + jjCheckNAddStates(41, 43); + break; + case 68: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 67; + break; + case 69: + if (curChar == 34 && kind > 783) + kind = 783; + break; + case 71: + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 73: + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + break; + case 75: + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + break; + case 78: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + break; + case 81: + if (curChar == 47) + jjAddStates(18, 19); + break; + case 82: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 83; + break; + case 83: + if ((0xffff7fffffffffffL & l) != 0L && kind > 770) + kind = 770; + break; + case 85: + if (curChar != 47) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 86: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 88: + if ((0xffffffffdfffffffL & l) != 0L) + jjCheckNAddStates(6, 8); + else if (curChar == 93) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 58: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 55: + jjCheckNAddStates(12, 14); + if ((0xffffff81ffffff81L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 87: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + else if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + else if ((0x1000000010L & l) != 0L) + { + if (kind > 729) + kind = 729; + } + if ((0x10000000100000L & l) != 0L) + { + if (kind > 730) + kind = 730; + } + break; + case 91: + case 29: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 123) + jjAddStates(44, 51); + else if (curChar == 91) + jjCheckNAddTwoStates(22, 24); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + else if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + else if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 1; + else if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 2: + jjAddStates(15, 17); + break; + case 6: + if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 7: + if ((0x7fffffe07fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 10: + jjAddStates(3, 5); + break; + case 14: + if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + break; + case 16: + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 21: + if (curChar == 91) + jjCheckNAddTwoStates(22, 24); + break; + case 22: + if ((0xffffffffdfffffffL & l) != 0L) + jjCheckNAddStates(6, 8); + break; + case 23: + if (curChar == 93) + jjCheckNAddStates(6, 8); + break; + case 24: + if (curChar == 93) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 25: + if (curChar == 93 && kind > 776) + kind = 776; + break; + case 26: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 31: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 38: + if ((0x2000000020L & l) != 0L) + jjAddStates(56, 57); + break; + case 51: + jjCheckNAddStates(12, 14); + break; + case 57: + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + break; + case 60: + jjAddStates(38, 40); + break; + case 66: + jjAddStates(41, 43); + break; + case 70: + if (curChar == 123) + jjAddStates(44, 51); + break; + case 72: + if ((0x1000000010L & l) != 0L && kind > 729) + kind = 729; + break; + case 74: + if ((0x10000000100000L & l) != 0L && kind > 730) + kind = 730; + break; + case 76: + if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + break; + case 77: + if ((0x8000000080000L & l) != 0L && kind > 731) + kind = 731; + break; + case 79: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + break; + case 80: + if ((0x400000004000L & l) != 0L && kind > 732) + kind = 732; + break; + case 83: + if (kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 89: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 86: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 88: + case 22: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(6, 8); + break; + case 58: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 55: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 91: + case 29: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 0: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 2: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(15, 17); + break; + case 10: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(3, 5); + break; + case 16: + if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) + break; + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 26: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 31: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 51: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + break; + case 60: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(38, 40); + break; + case 66: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(41, 43); + break; + case 83: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 86 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_6() +{ + return jjMoveNfa_6(1, 0); +} +private final int jjMoveNfa_6(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 2; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 0: + if (curChar == 47) + kind = 774; + break; + case 1: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 0; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + switch (pos) + { + case 0: + if ((active5 & 0x1fffffc00000L) != 0L || (active10 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + return 86; + } + if ((active10 & 0x80000000000L) != 0L) + { + jjmatchedKind = 781; + return 1; + } + if ((active11 & 0x20000000L) != 0L) + return 87; + if ((active9 & 0xf000000000000000L) != 0L || (active10 & 0xfffffL) != 0L || (active11 & 0x100L) != 0L) + { + jjmatchedKind = 781; + return 58; + } + if ((active11 & 0x20000000000000L) != 0L) + return 55; + if ((active11 & 0x1000000000000L) != 0L || (active12 & 0x9L) != 0L) + return 84; + if ((active0 & 0x7ffe000000000L) != 0L || (active2 & 0xfffffffffffffff0L) != 0L || (active3 & 0xffffe0007fffffffL) != 0L || (active4 & 0x7ffffe1fffffffL) != 0L || (active5 & 0xffffe00000000000L) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0x7fffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xfffffffffffffffL) != 0L || (active10 & 0x7f27f7fffff00000L) != 0L || (active11 & 0x95L) != 0L) + { + jjmatchedKind = 781; + return 88; + } + if ((active0 & 0xfff8001ffffffff8L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfL) != 0L || (active3 & 0x1fff80000000L) != 0L || (active4 & 0xff800001e0000000L) != 0L || (active5 & 0x3fffffL) != 0L || (active7 & 0x8000000000000000L) != 0L || (active10 & 0xd8000000000000L) != 0L || (active11 & 0x20000000000006aL) != 0L) + return 88; + if ((active11 & 0x400000000000L) != 0L) + return 15; + if ((active11 & 0x10000400000000L) != 0L) + return 89; + return -1; + case 1: + if ((active12 & 0x9L) != 0L) + return 82; + if ((active0 & 0x40007fe000000L) != 0L || (active3 & 0xfc00006000000000L) != 0L || (active4 & 0x200000007ffffL) != 0L || (active5 & 0x78e6001f00000000L) != 0L || (active9 & 0x6000000000L) != 0L || (active10 & 0xa811000000000000L) != 0L || (active11 & 0x40L) != 0L) + return 88; + if ((active0 & 0xfff3fff801fffff0L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xffffffffffffffffL) != 0L || (active3 & 0x3ffff9f7fffffffL) != 0L || (active4 & 0xff7dffffdff80000L) != 0L || (active5 & 0x8719ffe0ffffffffL) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0xffffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xffffff9fffffffffL) != 0L || (active10 & 0x57eeffffffffffffL) != 0L || (active11 & 0x1bfL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 781; + jjmatchedPos = 1; + } + return 88; + } + return -1; + case 2: + if ((active0 & 0xfff3dfef79e98c80L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfe1ff2ffffff09ffL) != 0L || (active3 & 0xfbfeffd77f87ff9fL) != 0L || (active4 & 0x3e7dfffa1fff40ffL) != 0L || (active5 & 0xf795ffeebffe03ffL) != 0L || (active6 & 0xf8fffffdc07fff78L) != 0L || (active7 & 0x1ffffffc3fffffffL) != 0L || (active8 & 0xfffL) != 0L || (active9 & 0xffffffdffff7fffeL) != 0L || (active10 & 0xfffef7ffffffffffL) != 0L || (active11 & 0x1ffL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 781; + jjmatchedPos = 2; + } + return 88; + } + if ((active0 & 0x201004167370L) != 0L || (active2 & 0x1e00d000000f600L) != 0L || (active3 & 0x1000800780060L) != 0L || (active4 & 0xc1000005c0003f00L) != 0L || (active5 & 0x4800104001fc00L) != 0L || (active6 & 0x70000023f800087L) != 0L || (active7 & 0xe0000003c0000000L) != 0L || (active8 & 0xfffffffffffff000L) != 0L || (active9 & 0x80001L) != 0L || (active10 & 0x80000000000L) != 0L) + return 88; + return -1; + case 3: + if ((active2 & 0x40000000000000L) != 0L) + return 90; + if ((active0 & 0x99c29fef79e9ece0L) != 0L || (active1 & 0xfff7cfffffffdc01L) != 0L || (active2 & 0xff9ae2fe1fffe80fL) != 0L || (active3 & 0xfbf87f9763f7ffd3L) != 0L || (active4 & 0xbe7d389b80075effL) != 0L || (active5 & 0xf605f86c3f37bbffL) != 0L || (active6 & 0xfe87f7fcff4fff06L) != 0L || (active7 & 0x9febfffdbf7fffffL) != 0L || (active8 & 0xffffffffffffefa6L) != 0L || (active9 & 0xf63fffd00ff7fffdL) != 0L || (active10 & 0xfefe061c3ffd07ffL) != 0L || (active11 & 0xf9L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 781; + jjmatchedPos = 3; + } + return 88; + } + if ((active0 & 0x6631400000000000L) != 0L || (active1 & 0x83000000023feL) != 0L || (active2 & 0x51001e00005f0L) != 0L || (active3 & 0x680401c00000cL) != 0L || (active4 & 0xc7601ff82000L) != 0L || (active5 & 0x190078280c80000L) != 0L || (active6 & 0x78080100300078L) != 0L || (active7 & 0x4014000200800000L) != 0L || (active8 & 0x59L) != 0L || (active9 & 0x9c0000ff0000002L) != 0L || (active10 & 0x100f1e3c002f800L) != 0L || (active11 & 0x106L) != 0L) + return 88; + return -1; + case 4: + if ((active0 & 0xd9e29e2f780120e0L) != 0L || (active1 & 0xfff3affffffe9bfcL) != 0L || (active2 & 0xd592e2ffd3ffe9a7L) != 0L || (active3 & 0xfbd86017637413dbL) != 0L || (active4 & 0x8020aac99fc75ef1L) != 0L || (active5 & 0xc605fb2c2711bbfbL) != 0L || (active6 & 0xfe83d7dcbf4fff74L) != 0L || (active7 & 0x1febf0ddbf1ffeffL) != 0L || (active8 & 0xffffffffffffeea6L) != 0L || (active9 & 0xf6bdffdf88f7f7e1L) != 0L || (active10 & 0xf5de02da3f80f2fcL) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 781; + jjmatchedPos = 4; + } + return 88; + } + if ((active2 & 0x40000000000000L) != 0L) + return 90; + if ((active0 & 0x1c001e8cc00L) != 0L || (active1 & 0x4400000014401L) != 0L || (active2 & 0x2a0800000c000008L) != 0L || (active3 & 0x241f800083ec00L) != 0L || (active4 & 0x3e5d10120000000eL) != 0L || (active5 & 0x3000044018a60004L) != 0L || (active6 & 0x24202040000002L) != 0L || (active7 & 0x80000f2000600100L) != 0L || (active8 & 0x100L) != 0L || (active9 & 0x200000700081cL) != 0L || (active10 & 0xa202404007d0503L) != 0L || (active11 & 0xc0L) != 0L) + return 88; + return -1; + case 5: + if ((active2 & 0x40000000000000L) != 0L) + return 90; + if ((active0 & 0xd9c2878e79c02040L) != 0L || (active1 & 0xfff1afffe67e9bfcL) != 0L || (active2 & 0x192e07fd20fc9a1L) != 0L || (active3 & 0xf9c84d072364834bL) != 0L || (active4 & 0xbc38a2c99fc65ed1L) != 0L || (active5 & 0x6000d12c2710a3b9L) != 0L || (active6 & 0xfe82d7dcaf4dff70L) != 0L || (active7 & 0x19e30e0dbd000effL) != 0L || (active8 & 0xffffffffffffee22L) != 0L || (active9 & 0xf2bdffdf8e17b6d1L) != 0L || (active10 & 0xf7ee028a3fc0f038L) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 781; + jjmatchedPos = 5; + } + return 88; + } + if ((active0 & 0x201821000100a0L) != 0L || (active1 & 0x2000019800000L) != 0L || (active2 & 0xd400028001f02006L) != 0L || (active3 & 0x210301040101090L) != 0L || (active4 & 0x80000010020L) != 0L || (active5 & 0x86052a0000051842L) != 0L || (active6 & 0x1000010020004L) != 0L || (active7 & 0x608f0d0021ff000L) != 0L || (active8 & 0x84L) != 0L || (active9 & 0x400000000e04120L) != 0L || (active10 & 0x100050002002c4L) != 0L) + return 88; + return -1; + case 6: + if ((active2 & 0x40000000000000L) != 0L) + return 90; + if ((active0 & 0x40038e79c02040L) != 0L || (active1 & 0x11a7f8f73c9bfcL) != 0L || (active2 & 0x8190007fc20c09a4L) != 0L || (active3 & 0x71c84c0623048102L) != 0L || (active4 & 0xb01880499fc41cd0L) != 0L || (active5 & 0x6000c12c0310a3b9L) != 0L || (active6 & 0x7e80c5d800097f50L) != 0L || (active7 & 0x5e20e898107c85fL) != 0L || (active8 & 0xfffffffffffbee20L) != 0L || (active9 & 0xe281ffcf8ed7b6d1L) != 0L || (active10 & 0xb7fa000a0340f000L) != 0L || (active11 & 0x9L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 781; + jjmatchedPos = 6; + } + return 88; + } + if ((active0 & 0xd982840000000000L) != 0L || (active1 & 0xffe0080700420000L) != 0L || (active2 & 0x2e0001063c001L) != 0L || (active3 & 0x8800010100600249L) != 0L || (active4 & 0xc20228000024201L) != 0L || (active5 & 0x400100024001000L) != 0L || (active6 & 0x80021204af448020L) != 0L || (active7 & 0x180180043c0806a0L) != 0L || (active8 & 0x40002L) != 0L || (active9 & 0x103c001000000000L) != 0L || (active10 & 0x400402803c800038L) != 0L || (active11 & 0x30L) != 0L) + return 88; + return -1; + case 7: + if ((active2 & 0x40000000000000L) != 0L) + return 90; + if ((active0 & 0x1040038e79c00000L) != 0L || (active1 & 0xffd1a1fef73c1bfcL) != 0L || (active2 & 0x8180c01782040985L) != 0L || (active3 & 0x71c0440203048002L) != 0L || (active4 & 0x301880409fc40c91L) != 0L || (active5 & 0x4000c02c010003b8L) != 0L || (active6 & 0x7e80c1800e097f40L) != 0L || (active7 & 0x15600e89b807c041L) != 0L || (active8 & 0xfff2ffffff13a000L) != 0L || (active9 & 0xe0b9ff4f8ed3b6d1L) != 0L || (active10 & 0xa7f800082200f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 7) + { + jjmatchedKind = 781; + jjmatchedPos = 7; + } + return 88; + } + if ((active0 & 0x100000000002040L) != 0L || (active1 & 0x60000008000L) != 0L || (active2 & 0x100068400a0020L) != 0L || (active3 & 0x8080420000100L) != 0L || (active4 & 0x8000000900001040L) != 0L || (active5 & 0x200001000210a001L) != 0L || (active6 & 0x45800000010L) != 0L || (active7 & 0x8200000100081eL) != 0L || (active8 & 0xd000000e84e20L) != 0L || (active9 & 0x200008000040000L) != 0L || (active10 & 0x1002000201400000L) != 0L || (active11 & 0x1L) != 0L) + return 88; + return -1; + case 8: + if ((active0 & 0x20610400000L) != 0L || (active1 & 0x108000f03c03f8L) != 0L || (active2 & 0x8080000000000000L) != 0L || (active3 & 0x70c0400202040002L) != 0L || (active4 & 0x18000000040c01L) != 0L || (active5 & 0x2c00000000L) != 0L || (active6 & 0x1880818000017f00L) != 0L || (active7 & 0x60000880040000L) != 0L || (active8 & 0x300004000000L) != 0L || (active9 & 0x2000f00388130410L) != 0L || (active10 & 0x8410000002000000L) != 0L) + return 88; + if ((active0 & 0x1040018869800000L) != 0L || (active1 & 0xffc121fe07001804L) != 0L || (active2 & 0x100c01782040985L) != 0L || (active3 & 0x100040001008000L) != 0L || (active4 & 0x300080409fc00090L) != 0L || (active5 & 0x4000c000010003b8L) != 0L || (active6 & 0x660040100e080040L) != 0L || (active7 & 0x15000e813803c041L) != 0L || (active8 & 0xfffacffffb13ac00L) != 0L || (active9 & 0xc0b90f4c06c0b2c1L) != 0L || (active10 & 0x23e800082000f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 8) + { + jjmatchedKind = 781; + jjmatchedPos = 8; + } + return 88; + } + return -1; + case 9: + if ((active0 & 0x468000000L) != 0L || (active1 & 0x100fe00000a00L) != 0L || (active2 & 0x1102040800L) != 0L || (active4 & 0x804098c00000L) != 0L || (active5 & 0x4000000801000200L) != 0L || (active6 & 0x2200400000000040L) != 0L || (active7 & 0x40100000041L) != 0L || (active8 & 0x2038000L) != 0L || (active9 & 0x80200002008240L) != 0L || (active10 & 0x280000020000000L) != 0L || (active11 & 0x8L) != 0L) + return 88; + if ((active0 & 0x1040018801800000L) != 0L || (active1 & 0xffc02100c73811f4L) != 0L || (active2 & 0x100c00680000185L) != 0L || (active3 & 0x180040001008000L) != 0L || (active4 & 0x3010000007000890L) != 0L || (active5 & 0xc000000001b8L) != 0L || (active6 & 0x440000100e087e00L) != 0L || (active7 & 0x15000a803803c000L) != 0L || (active8 & 0xfffacffff9102c00L) != 0L || (active9 & 0xc0398f4f04c23081L) != 0L || (active10 & 0x216800080000f000L) != 0L) + { + if (jjmatchedPos != 9) + { + jjmatchedKind = 781; + jjmatchedPos = 9; + } + return 88; + } + return -1; + case 10: + if ((active0 & 0x1000010801800000L) != 0L || (active1 & 0xf7c02074863811f0L) != 0L || (active2 & 0x100c00200000181L) != 0L || (active3 & 0x100040000000000L) != 0L || (active4 & 0x3010000000800880L) != 0L || (active5 & 0xc00000000038L) != 0L || (active6 & 0x400000100e007e00L) != 0L || (active7 & 0x11000a003803c000L) != 0L || (active8 & 0xffca8ffff0002c00L) != 0L || (active9 & 0x8038804f00021000L) != 0L || (active10 & 0x2800080000f000L) != 0L) + { + if (jjmatchedPos != 10) + { + jjmatchedKind = 781; + jjmatchedPos = 10; + } + return 88; + } + if ((active0 & 0x40008000000000L) != 0L || (active1 & 0x800018041000004L) != 0L || (active2 & 0x480000004L) != 0L || (active3 & 0x80000001008000L) != 0L || (active4 & 0x7000010L) != 0L || (active5 & 0x180L) != 0L || (active6 & 0x400000000080000L) != 0L || (active7 & 0x400008000000000L) != 0L || (active8 & 0x30400009100000L) != 0L || (active9 & 0x40010f0004c02081L) != 0L || (active10 & 0x2140000000000000L) != 0L) + return 88; + return -1; + case 11: + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x6680000000001000L) != 0L || (active2 & 0x1L) != 0L || (active3 & 0x40000000000L) != 0L || (active4 & 0x1000000000000880L) != 0L || (active5 & 0x800000000020L) != 0L || (active6 & 0x8000000L) != 0L || (active7 & 0x1100080010000000L) != 0L || (active8 & 0x6082800000002800L) != 0L || (active9 & 0x10000100000000L) != 0L || (active10 & 0x8000800000000L) != 0L) + return 88; + if ((active0 & 0x10801800000L) != 0L || (active1 & 0x91402074863801f0L) != 0L || (active2 & 0x100c00200000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004800000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x9f480ffff0000400L) != 0L || (active9 & 0x80288e4e00021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 11) + { + jjmatchedKind = 781; + jjmatchedPos = 11; + } + return 88; + } + return -1; + case 12: + if ((active0 & 0x800000000L) != 0L || (active1 & 0x200000000000L) != 0L || (active2 & 0x100000200000000L) != 0L || (active4 & 0x800000L) != 0L || (active8 & 0x8408000000000400L) != 0L || (active9 & 0x8000000600000000L) != 0L) + return 88; + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xd1400074863801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004000000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x1b400ffff0000000L) != 0L || (active9 & 0x288e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 12; + return 88; + } + return -1; + case 13: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xc1400074862801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x6007800L) != 0L || (active7 & 0x803c000L) != 0L || (active8 & 0x9400ffff0000000L) != 0L || (active9 & 0x88e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 13; + return 88; + } + if ((active1 & 0x1000000000100000L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x10000004000000L) != 0L || (active5 & 0x8L) != 0L || (active6 & 0x4000001000000600L) != 0L || (active7 & 0x20020000000L) != 0L || (active8 & 0x1200000000000000L) != 0L || (active9 & 0x20000000000000L) != 0L) + return 88; + return -1; + case 14: + if ((active0 & 0x1800000L) != 0L || (active1 & 0xc1000050862800f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x1400bfff0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 14; + return 88; + } + if ((active0 & 0x10000000000L) != 0L || (active1 & 0x40002400000100L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active6 & 0x6000000L) != 0L || (active7 & 0x8008000L) != 0L || (active8 & 0x800040000000000L) != 0L || (active9 & 0x8804800021000L) != 0L) + return 88; + return -1; + case 15: + if ((active0 & 0x1000000L) != 0L || (active1 & 0xc1000050000800e0L) != 0L || (active2 & 0x180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x14003ff00000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 15) + { + jjmatchedKind = 781; + jjmatchedPos = 15; + } + return 88; + } + if ((active0 & 0x800000L) != 0L || (active1 & 0x86200010L) != 0L || (active2 & 0xc00000000000L) != 0L || (active8 & 0x800f0000000L) != 0L) + return 88; + return -1; + case 16: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000010040000e0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x1400078e0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 16) + { + jjmatchedKind = 781; + jjmatchedPos = 16; + } + return 88; + } + if ((active1 & 0x4000004000080000L) != 0L || (active5 & 0x400000000000L) != 0L || (active7 & 0x20000L) != 0L || (active8 & 0x38700000000L) != 0L) + return 88; + return -1; + case 17: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x140015ee0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 17; + return 88; + } + if ((active1 & 0x1000000040L) != 0L || (active8 & 0x2000000000L) != 0L) + return 88; + return -1; + case 18: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x106e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 18) + { + jjmatchedKind = 781; + jjmatchedPos = 18; + } + return 88; + } + if ((active8 & 0x140005800000000L) != 0L || (active9 & 0x20000000000L) != 0L) + return 88; + return -1; + case 19: + if ((active1 & 0x80L) != 0L || (active5 & 0x10L) != 0L || (active7 & 0x4000L) != 0L) + return 88; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x8100000004000020L) != 0L || (active2 & 0x800000000180L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x10000L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 19; + return 88; + } + return -1; + case 20: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x180L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 20; + return 88; + } + if ((active0 & 0x1000000L) != 0L || (active1 & 0x4000020L) != 0L || (active2 & 0x800000000000L) != 0L || (active7 & 0x10000L) != 0L) + return 88; + return -1; + case 21: + if ((active2 & 0x80L) != 0L || (active9 & 0x40000000000L) != 0L || (active10 & 0x6000L) != 0L) + return 88; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 21; + return 88; + } + return -1; + case 22: + if ((active6 & 0x2000L) != 0L) + return 88; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 22; + return 88; + } + return -1; + case 23: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000001000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 23; + return 88; + } + if ((active8 & 0x20000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x8000L) != 0L) + return 88; + return -1; + case 24: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x1800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 24; + return 88; + } + if ((active6 & 0x4000L) != 0L || (active10 & 0x1000L) != 0L) + return 88; + return -1; + case 25: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active8 & 0x1600000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 25; + return 88; + } + if ((active6 & 0x1800L) != 0L || (active8 & 0x100c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + return 88; + return -1; + case 26: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 26; + return 88; + } + if ((active2 & 0x100L) != 0L || (active8 & 0x600000000L) != 0L) + return 88; + return -1; + case 27: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 27; + return 88; + } + return -1; + case 28: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 28; + return 88; + } + if ((active8 & 0x1000000000L) != 0L) + return 88; + return -1; + case 29: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 29; + return 88; + } + return -1; + case 30: + if ((active1 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 30; + return 88; + } + if ((active1 & 0x100000000000000L) != 0L) + return 88; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_2(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12), pos + 1); +} +private final int jjStartNfaWithStates_2(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_2(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_2() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 1; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000L, 0x0L); + case 34: + return jjStopAtPos(0, 758); + case 36: + return jjStartNfaWithStates_2(0, 761, 88); + case 37: + return jjStopAtPos(0, 753); + case 39: + return jjStartNfaWithStates_2(0, 757, 55); + case 40: + return jjStopAtPos(0, 727); + case 41: + return jjStopAtPos(0, 728); + case 42: + jjmatchedKind = 751; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L); + case 43: + return jjStopAtPos(0, 749); + case 44: + return jjStopAtPos(0, 739); + case 45: + return jjStartNfaWithStates_2(0, 750, 15); + case 46: + jjmatchedKind = 738; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x10000000000000L, 0x0L); + case 47: + jjmatchedKind = 752; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x9L); + case 58: + jjmatchedKind = 744; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L); + case 59: + return jjStopAtPos(0, 737); + case 60: + jjmatchedKind = 742; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xa0000000000L, 0x0L); + case 61: + jjmatchedKind = 740; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000L, 0x0L); + case 62: + jjmatchedKind = 741; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x40000000000L, 0x0L); + case 63: + return jjStopAtPos(0, 743); + case 91: + return jjStopAtPos(0, 735); + case 93: + return jjStopAtPos(0, 736); + case 94: + return jjStopAtPos(0, 760); + case 65: + case 97: + jjmatchedKind = 3; + return jjMoveStringLiteralDfa1_2(0x1ffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x18000000000000L, 0x40L, 0x0L); + case 66: + case 98: + return jjMoveStringLiteralDfa1_2(0x7ffe000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L, 0x0L); + case 67: + case 99: + jjmatchedKind = 51; + return jjMoveStringLiteralDfa1_2(0xfff0000000000000L, 0xffffffffffffffffL, 0xfL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xc0000000000000L, 0x28L, 0x0L); + case 68: + case 100: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0xfffffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000000L, 0x0L, 0x0L); + case 69: + case 101: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0xffff000000000000L, 0x3ffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L, 0x0L); + case 70: + case 102: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x7ffffc00L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 71: + case 103: + jjmatchedKind = 223; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x1fff00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 72: + case 104: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x7e00000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 73: + case 105: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0xfff8000000000000L, 0x7ffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2801000000000000L, 0x0L, 0x0L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x1ff80000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 75: + case 107: + jjmatchedKind = 285; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x1c0000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L, 0x0L); + case 76: + case 108: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffe00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000000L, 0x0L, 0x0L); + case 77: + case 109: + jjmatchedKind = 311; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0xff00000000000000L, 0x3fffffL, 0x0L, 0x8000000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 78: + case 110: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1fffffc00000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000000L, 0x0L, 0x0L); + case 79: + case 111: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xffffe00000000000L, 0x7fL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 80: + case 112: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1ffffffffff80L, 0x0L, 0x0L, 0x0L, 0x1000000000000000L, 0x1L, 0x0L); + case 81: + case 113: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80L, 0x0L); + case 82: + case 114: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffc000000000000L, 0x7ffffffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 83: + case 115: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffff800000000L, 0xffffffffffffffffL, 0xffffffL, 0x800000000000L, 0x14L, 0x0L); + case 84: + case 116: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffffffff000000L, 0x2000000000000L, 0x0L, 0x0L); + case 85: + case 117: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xf000000000000000L, 0xfffffL, 0x100L, 0x0L); + case 86: + case 118: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x20000007ff00000L, 0x0L, 0x0L); + case 87: + case 119: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2007ff80000000L, 0x0L, 0x0L); + case 88: + case 120: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80000000000L, 0x0L, 0x0L); + case 89: + case 121: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x300000000000L, 0x0L, 0x0L); + case 90: + case 122: + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000L, 0x0L, 0x0L); + case 123: + return jjStartNfaWithStates_2(0, 733, 87); + case 124: + jjmatchedKind = 759; + return jjMoveStringLiteralDfa1_2(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L); + case 125: + return jjStopAtPos(0, 734); + case 126: + return jjStopAtPos(0, 2); + default : + return jjMoveNfa_2(0, 0); + } +} +private final int jjMoveStringLiteralDfa1_2(long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 1; + } + switch(curChar) + { + case 42: + if ((active12 & 0x8L) != 0L) + { + jjmatchedKind = 771; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0x1L); + case 46: + if ((active11 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 756); + break; + case 47: + if ((active12 & 0x2L) != 0L) + return jjStopAtPos(1, 769); + break; + case 58: + if ((active11 & 0x400000000000000L) != 0L) + return jjStopAtPos(1, 762); + break; + case 61: + if ((active11 & 0x20000000000L) != 0L) + return jjStopAtPos(1, 745); + else if ((active11 & 0x40000000000L) != 0L) + return jjStopAtPos(1, 746); + else if ((active11 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 748); + break; + case 62: + if ((active11 & 0x80000000000L) != 0L) + return jjStopAtPos(1, 747); + else if ((active11 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 755); + break; + case 65: + case 97: + return jjMoveStringLiteralDfa2_2(active0, 0x1ff0000000000000L, active1, 0L, active2, 0x10000000007f0L, active3, 0x200000000400L, active4, 0xff0000fe00080000L, active5, 0x7c00000L, active6, 0xc0000007fff80L, active7, 0x800000000L, active8, 0L, active9, 0x7000000L, active10, 0x13c400000ff00000L, active11, 0x1L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa2_2(active0, 0x70L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa2_2(active0, 0x80L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1c00018000000L, active6, 0L, active7, 0x1ff000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x4L, active12, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa2_2(active0, 0x700L, active1, 0L, active2, 0L, active3, 0x8000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa2_2(active0, 0xe00007e000000000L, active1, 0L, active2, 0x3fffff800L, active3, 0xf00000800L, active4, 0x1f01c0000000L, active5, 0xe000007fL, active6, 0xfff000003f800000L, active7, 0x7fffe000001fffffL, active8, 0L, active9, 0x1000000008000000L, active10, 0x2b000b0000000L, active11, 0x10L, active12, 0L); + case 70: + case 102: + if ((active5 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 369; + jjmatchedPos = 1; + } + else if ((active10 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(1, 688, 88); + return jjMoveStringLiteralDfa2_2(active0, 0x800L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x4000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000000000000L, active11, 0L, active12, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x10000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x7ffL, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1L, active9, 0x10000000L, active10, 0x700000000L, active11, 0L, active12, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa2_2(active0, 0x380000000000L, active1, 0L, active2, 0x7c00000000L, active3, 0x40000000f000L, active4, 0x1e00000000000L, active5, 0x3f80L, active6, 0x40000000L, active7, 0x8000000000200000L, active8, 0xeL, active9, 0x1fe0000000L, active10, 0xf840000000L, active11, 0x2L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa2_2(active0, 0x40000001f000L, active1, 0x7800L, active2, 0x6000000000000L, active3, 0x20001000030000L, active4, 0L, active5, 0x8000000000000L, active6, 0x380000000L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0x8000000000000L, active3, 0x3c0000000000000L, active4, 0L, active5, 0x10000000000000L, active6, 0L, active7, 0L, active8, 0x20L, active9, 0L, active10, 0x80000000000L, active11, 0L, active12, 0L); + case 78: + case 110: + if ((active3 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 250; + jjmatchedPos = 1; + } + else if ((active4 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(1, 305, 88); + else if ((active5 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 373; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0x60000L, active1, 0L, active2, 0x1f0000000000000L, active3, 0xf800000000000000L, active4, 0x7fffL, active5, 0xc0000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe000000000000000L, active10, 0x2c0000000000007fL, active11, 0L, active12, 0L); + case 79: + case 111: + if ((active3 & 0x2000000000L) != 0L) + { + jjmatchedKind = 229; + jjmatchedPos = 1; + } + else if ((active5 & 0x100000000L) != 0L) + { + jjmatchedKind = 352; + jjmatchedPos = 1; + } + else if ((active9 & 0x2000000000L) != 0L) + { + jjmatchedKind = 613; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0x1800000000000L, active1, 0x1ffffffff8000L, active2, 0xf8000000000L, active3, 0x7804000fc0000L, active4, 0x7c000000100000L, active5, 0x1e000fc000L, active6, 0x3c00000000L, active7, 0x3ff800000L, active8, 0xc0L, active9, 0x4000000000L, active10, 0xc000410000000000L, active11, 0x28L, active12, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa2_2(active0, 0x80000L, active1, 0L, active2, 0x200000000000000L, active3, 0L, active4, 0L, active5, 0x700000000000000L, active6, 0L, active7, 0L, active8, 0xf00L, active9, 0L, active10, 0x380L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0x400000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xfffffffffffff000L, active9, 0x3L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active5 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 379; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0x2000001f00000L, active1, 0x6000000000000L, active2, 0x800100000000000L, active3, 0x1f800f000000L, active4, 0L, active5, 0x7000000000000000L, active6, 0xffc000000000L, active7, 0L, active8, 0L, active9, 0x3ffff8000000000L, active10, 0x20060000000000L, active11, 0L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + else if ((active4 & 0x8000L) != 0L) + { + jjmatchedKind = 271; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0x7c000000L, active1, 0L, active2, 0x1000000000000000L, active3, 0L, active4, 0x1fe70000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x1fc00L, active11, 0x40L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_2(active0, 0x700000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000006000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xffcL, active10, 0x100000000e0000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa2_2(active0, 0x800000000L, active1, 0xfff8000000000000L, active2, 0x7L, active3, 0x70000000L, active4, 0L, active5, 0x1f8000300000L, active6, 0x3000000000007L, active7, 0x400000000L, active8, 0L, active9, 0x4000000000ff000L, active10, 0L, active11, 0x180L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa2_2(active0, 0x1000000000L, active1, 0L, active2, 0x2000000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x78L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0xc000000000000000L, active3, 0x3ffL, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(1, 50, 88); + return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0L, active2, 0xe00000000008L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800000000f00000L, active10, 0L, active11, 0L, active12, 0L); + case 124: + if ((active11 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 754); + break; + default : + break; + } + return jjStartNfa_2(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa2_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_2(0, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 2; + } + switch(curChar) + { + case 43: + if ((active12 & 0x1L) != 0L) + return jjStopAtPos(2, 768); + break; + case 65: + case 97: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_2(2, 8, 88); + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x9bffL, active2, 0x400000800L, active3, 0x18003000000L, active4, 0x30000000000L, active5, 0x1L, active6, 0x72000180000000L, active7, 0x203000000000L, active8, 0x120L, active9, 0x1ff800000003cL, active10, 0x320000000400L, active11, 0x4L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x8000000010000L, active2, 0L, active3, 0L, active4, 0x200200000000L, active5, 0L, active6, 0x1000000000000L, active7, 0L, active8, 0L, active9, 0x200000000703f000L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(2, 26, 88); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0xd01100000000e008L, active3, 0x3800000000000003L, active4, 0x3c000000000000L, active5, 0x400000000080L, active6, 0x80000000000000L, active7, 0x3c00000000000L, active8, 0L, active9, 0xc000000000040000L, active10, 0x4c4000000000000L, active11, 0L, active12, 0L); + case 68: + case 100: + if ((active0 & 0x200L) != 0L) + return jjStartNfaWithStates_2(2, 9, 88); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(2, 17, 88); + else if ((active2 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 181; + jjmatchedPos = 2; + } + else if ((active5 & 0x4000L) != 0L) + { + jjmatchedKind = 334; + jjmatchedPos = 2; + } + else if ((active5 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(2, 371, 88); + else if ((active6 & 0x80L) != 0L) + return jjStartNfaWithStates_2(2, 391, 88); + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0x1c0000000000000L, active3, 0x4000000000000000L, active4, 0L, active5, 0x7000000000018000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x800000800000081L, active11, 0L, active12, 0L); + case 69: + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(2, 20, 88); + else if ((active5 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(2, 374, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x2000008000000L, active1, 0x2000000000400L, active2, 0x2002000000000000L, active3, 0x840000400000cL, active4, 0L, active5, 0x100000000000000L, active6, 0xfc000000078L, active7, 0x4000000000000L, active8, 0xe00L, active9, 0x2000030000000L, active10, 0x7c000f800L, active11, 0x80L, active12, 0L); + case 70: + case 102: + if ((active6 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 440; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x2000000000L, active1, 0L, active2, 0x7f0000L, active3, 0L, active4, 0x40000000000L, active5, 0x4000000000000L, active6, 0x600000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000000e0000L, active11, 0L, active12, 0L); + case 71: + case 103: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(2, 36, 88); + else if ((active4 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(2, 290, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x9c000000000L, active1, 0L, active2, 0x800000L, active3, 0L, active4, 0L, active5, 0L, active6, 0xf800000000000000L, active7, 0x20000fL, active8, 0L, active9, 0L, active10, 0x4000000000000000L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000002008000000L, active6, 0L, active7, 0xc000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 73: + case 105: + if ((active6 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(2, 417, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x6000000000000000L, active1, 0L, active2, 0L, active3, 0x8020000000000010L, active4, 0x100001L, active5, 0x10004000000000L, active6, 0x700000000000L, active7, 0x400000L, active8, 0x10L, active9, 0xfc000000000000L, active10, 0x20040000010006L, active11, 0x100L, active12, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0xc00000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L, active12, 0L); + case 76: + case 108: + if ((active0 & 0x1000L) != 0L) + { + jjmatchedKind = 12; + jjmatchedPos = 2; + } + else if ((active8 & 0x1000L) != 0L) + { + jjmatchedKind = 524; + jjmatchedPos = 2; + } + else if ((active10 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(2, 683, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x30000000006000L, active1, 0x1fe0000L, active2, 0x1000000L, active3, 0x800010041400L, active4, 0L, active5, 0x80078010100300L, active6, 0L, active7, 0x18000003800030L, active8, 0xffffffffffffe000L, active9, 0x1L, active10, 0xa200000000700000L, active11, 0x2L, active12, 0L); + case 77: + case 109: + if ((active9 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(2, 595, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x400L, active1, 0x1000001e000000L, active2, 0x8000000000L, active3, 0xc0000000000000L, active4, 0x1000000000000L, active5, 0x180000e00002L, active6, 0L, active7, 0L, active8, 0x46L, active9, 0x400000fc8100000L, active10, 0x2800000000000L, active11, 0x20L, active12, 0L); + case 78: + case 110: + if ((active5 & 0x400L) != 0L) + { + jjmatchedKind = 330; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x8000100000000000L, active1, 0xfffe0000000L, active2, 0xe00002000000L, active3, 0x10000320002000L, active4, 0x80800000002L, active5, 0x201063800L, active6, 0xc000000000000L, active7, 0x8020000400000000L, active8, 0L, active9, 0x1000000000L, active10, 0x401000000060L, active11, 0x8L, active12, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa3_2(active0, 0xc00100000000L, active1, 0x4000000006000L, active2, 0x200100000000000L, active3, 0x1e1408030000L, active4, 0x1fe70004L, active5, 0L, active6, 0x800000000000L, active7, 0xf0000000000L, active8, 0x1L, active9, 0L, active10, 0x10000000000000L, active11, 0L, active12, 0L); + case 80: + case 112: + if ((active3 & 0x20L) != 0L) + { + jjmatchedKind = 197; + jjmatchedPos = 2; + } + else if ((active3 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(2, 240, 88); + else if ((active4 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(2, 312, 88); + return jjMoveStringLiteralDfa3_2(active0, 0x80000L, active1, 0L, active2, 0x8000004000000L, active3, 0x300000000000040L, active4, 0x8L, active5, 0L, active6, 0L, active7, 0x400000000000c0L, active8, 0L, active9, 0x800004000000000L, active10, 0x110L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active3 & 0x80000L) != 0L) + { + jjmatchedKind = 211; + jjmatchedPos = 2; + } + else if ((active6 & 0x800000L) != 0L) + { + jjmatchedKind = 407; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x40020001e00000L, active1, 0xffe0300000000000L, active2, 0x800000018000007L, active3, 0x70c000L, active4, 0x1000000000L, active5, 0xc00080004L, active6, 0x43f01ff00L, active7, 0x700100000000000L, active8, 0L, active9, 0x702L, active10, 0x100001003f800000L, active11, 0x10L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x10L) != 0L) + { + jjmatchedKind = 4; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x780000030000060L, active1, 0L, active2, 0x40079e0000000L, active3, 0x40000000L, active4, 0x60000000f0L, active5, 0x20000038L, active6, 0x18001e0000L, active7, 0x1800000000001f00L, active8, 0L, active9, 0x1000000000e00000L, active10, 0x200L, active11, 0x1L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(2, 45, 88); + else if ((active2 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(2, 168, 88); + else if ((active3 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(2, 227, 88); + else if ((active4 & 0x100L) != 0L) + { + jjmatchedKind = 264; + jjmatchedPos = 2; + } + else if ((active5 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(2, 356, 88); + else if ((active6 & 0x1L) != 0L) + { + jjmatchedKind = 384; + jjmatchedPos = 2; + } + else if ((active7 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 509; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x1801040e00008880L, active1, 0L, active2, 0x2000001f0L, active3, 0x4000000b80L, active4, 0x3e00008000003e00L, active5, 0x601800006000040L, active6, 0x600006L, active7, 0x40000000000fe000L, active8, 0L, active9, 0L, active10, 0x10000e000000000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x400000000000L, active2, 0x400020000000000L, active3, 0x6000000800000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000000L, active8, 0x80L, active9, 0x300000000000000L, active10, 0L, active11, 0L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x1800000000000L, active2, 0L, active3, 0x200000000000L, active4, 0x100000084000L, active5, 0L, active6, 0x40000000L, active7, 0x800100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 87: + case 119: + if ((active2 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(2, 170, 88); + else if ((active5 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(2, 350, 88); + else if ((active7 & 0x40000000L) != 0L) + { + jjmatchedKind = 478; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x40000000000000L, active5, 0L, active6, 0x2000000000L, active7, 0x380000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + if ((active4 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 318; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x80000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(2, 18, 88); + else if ((active2 & 0x200L) != 0L) + { + jjmatchedKind = 137; + jjmatchedPos = 2; + } + else if ((active2 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(2, 171, 88); + else if ((active4 & 0x40000000L) != 0L) + { + jjmatchedKind = 286; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_2(active0, 0x40000000L, active1, 0L, active2, 0x400L, active3, 0L, active4, 0x180000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800L, active10, 0L, active11, 0x40L, active12, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + default : + break; + } + return jjStartNfa_2(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa3_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_2(1, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 3; + } + switch(curChar) + { + case 45: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 49: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x40000L, active11, 0L); + case 51: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000L, active11, 0L); + case 56: + if ((active10 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(3, 657, 88); + break; + case 95: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0x180000000000000L, active3, 0L, active4, 0x180000000L, active5, 0x2000000000L, active6, 0L, active7, 0x180000000L, active8, 0xffffffffffff0000L, active9, 0x4000000001L, active10, 0x1800000L, active11, 0L); + case 65: + case 97: + if ((active2 & 0x10L) != 0L) + { + jjmatchedKind = 132; + jjmatchedPos = 3; + } + else if ((active4 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(3, 275, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x1802100001e10000L, active1, 0x3800000000000L, active2, 0x1400e08800032020L, active3, 0x12000L, active4, 0x3c000000000000L, active5, 0x8000000L, active6, 0x7f00L, active7, 0x40000000000010L, active8, 0L, active9, 0x2000000000000L, active10, 0x11000000000000a0L, active11, 0L); + case 66: + case 98: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(3, 46, 88); + else if ((active1 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(3, 77, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0x20000000000L, active3, 0x1000000000L, active4, 0L, active5, 0x80000000002L, active6, 0L, active7, 0L, active8, 0L, active9, 0x400000000000000L, active10, 0x2000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x20000000L) != 0L) + { + jjmatchedKind = 157; + jjmatchedPos = 3; + } + else if ((active3 & 0x4L) != 0L) + { + jjmatchedKind = 194; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_2(active0, 0x180000000000000L, active1, 0x400L, active2, 0x2000011c0000000L, active3, 0x21000808L, active4, 0x3e00000000000000L, active5, 0L, active6, 0x81c08f020000L, active7, 0L, active8, 0xf00L, active9, 0x1000000000041000L, active10, 0x4000000L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(3, 239, 88); + else if ((active4 & 0x10000000000L) != 0L) + { + jjmatchedKind = 296; + jjmatchedPos = 3; + } + else if ((active6 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 436; + jjmatchedPos = 3; + } + else if ((active11 & 0x100L) != 0L) + return jjStartNfaWithStates_2(3, 712, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x40000000000000L, active1, 0xe0000000L, active2, 0L, active3, 0L, active4, 0x20000010000L, active5, 0L, active6, 0x20000000000000L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x1000000000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 57, 88); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 115, 88); + else if ((active2 & 0x40L) != 0L) + { + jjmatchedKind = 134; + jjmatchedPos = 3; + } + else if ((active2 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 178, 88); + else if ((active3 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(3, 218, 88); + else if ((active4 & 0x400000000000L) != 0L) + { + jjmatchedKind = 302; + jjmatchedPos = 3; + } + else if ((active5 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(3, 339, 88); + else if ((active5 & 0x400000L) != 0L) + { + jjmatchedKind = 342; + jjmatchedPos = 3; + } + else if ((active5 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(3, 353, 88); + else if ((active7 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(3, 471, 88); + else if ((active8 & 0x8L) != 0L) + return jjStartNfaWithStates_2(3, 515, 88); + else if ((active8 & 0x40L) != 0L) + return jjStartNfaWithStates_2(3, 518, 88); + else if ((active9 & 0x40000000L) != 0L) + { + jjmatchedKind = 606; + jjmatchedPos = 3; + } + else if ((active9 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 632, 88); + else if ((active9 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 635, 88); + else if ((active10 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(3, 686, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x10008820L, active1, 0x10000000000000L, active2, 0xc0000002090c0180L, active3, 0xc0000300200180L, active4, 0x40908200001e32L, active5, 0xb001b00000800000L, active6, 0x600002000000002L, active7, 0x800c800000160L, active8, 0x2000L, active9, 0xf80000100L, active10, 0x800000000000341L, active11, 0L); + case 70: + case 102: + if ((active7 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 500, 88); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0x400000000L, active3, 0L, active4, 0x81800000000L, active5, 0x4L, active6, 0x4000000000000L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x4000000000000400L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 48, 88); + else if ((active2 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 176, 88); + else if ((active6 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(3, 405, 88); + else if ((active10 & 0x2000000000L) != 0L) + { + jjmatchedKind = 677; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_2(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x40L, active6, 0L, active7, 0x200000L, active8, 0L, active9, 0L, active10, 0xc000c000000000L, active11, 0L); + case 73: + case 105: + if ((active10 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(3, 687, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x9c020000480L, active1, 0x1L, active2, 0x10704000L, active3, 0x4000200040000000L, active4, 0x1000000000000L, active5, 0x4600000002008000L, active6, 0x1810000000L, active7, 0x100000000000000L, active8, 0x2L, active9, 0x8000000200L, active10, 0x2008000000000010L, active11, 0L); + case 75: + case 107: + if ((active6 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 435, 88); + else if ((active7 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 498, 88); + else if ((active10 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(3, 671, 88); + else if ((active10 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(3, 680, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x20000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0x4000000000000L, active11, 0L); + case 76: + case 108: + if ((active0 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + } + else if ((active0 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 61; + jjmatchedPos = 3; + } + else if ((active3 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(3, 220, 88); + else if ((active5 & 0x8000000000L) != 0L) + { + jjmatchedKind = 359; + jjmatchedPos = 3; + } + else if ((active6 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 438, 88); + else if ((active11 & 0x2L) != 0L) + return jjStartNfaWithStates_2(3, 705, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x4020800000080000L, active1, 0x7e8000L, active2, 0x8808L, active3, 0x1900000000040043L, active4, 0x40000L, active5, 0x74000000300L, active6, 0x1000000000000L, active7, 0x3003000080L, active8, 0x20L, active9, 0x7000800L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active3 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(3, 219, 88); + else if ((active9 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 630; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_2(active0, 0x140000000L, active1, 0x1e000000L, active2, 0x2000000000000L, active3, 0x402100000L, active4, 0L, active5, 0xc00000000L, active6, 0x100020000000L, active7, 0L, active8, 0L, active9, 0x80000000102000L, active10, 0x10000000000000L, active11, 0L); + case 78: + case 110: + if ((active4 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(3, 276, 88); + else if ((active4 & 0x200000L) != 0L) + { + jjmatchedKind = 277; + jjmatchedPos = 3; + } + else if ((active5 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 376, 88); + else if ((active6 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(3, 416, 88); + else if ((active9 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(3, 604, 88); + else if ((active10 & 0x100000000L) != 0L) + { + jjmatchedKind = 672; + jjmatchedPos = 3; + } + else if ((active11 & 0x4L) != 0L) + return jjStartNfaWithStates_2(3, 706, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x20008000000L, active1, 0x400700000000L, active2, 0L, active3, 0x8018000800000L, active4, 0x1fc00000L, active5, 0L, active6, 0L, active7, 0x400000000L, active8, 0L, active9, 0x201ff0000000000L, active10, 0x200010008L, active11, 0x40L); + case 79: + case 111: + if ((active3 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(3, 230, 88); + else if ((active4 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(3, 269, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x2000006040L, active1, 0x10000L, active2, 0x810000000000000L, active3, 0x210000000020000L, active4, 0x4000L, active5, 0x11000000L, active6, 0x200040000000L, active7, 0xd00000100000L, active8, 0L, active9, 0xe000000000000000L, active10, 0x8000000000000002L, active11, 0L); + case 80: + case 112: + if ((active2 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(3, 172, 88); + else if ((active8 & 0x10L) != 0L) + return jjStartNfaWithStates_2(3, 516, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0x2000000000L, active3, 0L, active4, 0L, active5, 0x200000L, active6, 0x20000000004L, active7, 0xf0000000200L, active8, 0x4L, active9, 0x8000000L, active10, 0x2020000000000L, active11, 0x20L); + case 81: + case 113: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x2L) != 0L) + { + jjmatchedKind = 65; + jjmatchedPos = 3; + } + else if ((active1 & 0x100000000000L) != 0L) + { + jjmatchedKind = 108; + jjmatchedPos = 3; + } + else if ((active3 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 241; + jjmatchedPos = 3; + } + else if ((active6 & 0x8L) != 0L) + { + jjmatchedKind = 387; + jjmatchedPos = 3; + } + else if ((active10 & 0x800L) != 0L) + { + jjmatchedKind = 651; + jjmatchedPos = 3; + } + else if ((active10 & 0x100000000000L) != 0L) + { + jjmatchedKind = 684; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_2(active0, 0x600000000L, active1, 0xffe02000000003fcL, active2, 0x2000000000800001L, active3, 0x2004400000000200L, active4, 0x200000000000L, active5, 0x80L, active6, 0xf802000000000070L, active7, 0x20000000000fL, active8, 0x80L, active9, 0x4L, active10, 0x40020040000f000L, active11, 0x80L); + case 83: + case 115: + if ((active2 & 0x400L) != 0L) + return jjStartNfaWithStates_2(3, 138, 88); + else if ((active7 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(3, 481, 88); + else if ((active7 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 510, 88); + else if ((active9 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(3, 605, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x401f800005800L, active2, 0x2000006L, active3, 0xc410L, active4, 0L, active5, 0x4000000000039L, active6, 0x400000c0000L, active7, 0x1820000000000000L, active8, 0x4000L, active9, 0x3c000L, active10, 0x30000000L, active11, 0x1L); + case 84: + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 58, 88); + else if ((active4 & 0x2000000000L) != 0L) + { + jjmatchedKind = 293; + jjmatchedPos = 3; + } + else if ((active4 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(3, 298, 88); + else if ((active5 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(3, 351, 88); + else if ((active5 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 372, 88); + else if ((active6 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(3, 404, 88); + else if ((active9 & 0x2L) != 0L) + return jjStartNfaWithStates_2(3, 577, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x8000000000000000L, active1, 0x60000000000L, active2, 0x8004004000000L, active3, 0x8000000000401000L, active4, 0x40000000c1L, active5, 0x20160000L, active6, 0x400418000L, active7, 0x100003c000c00L, active8, 0L, active9, 0xe00038L, active10, 0x20040800000000L, active11, 0x8L); + case 85: + case 117: + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x1800000L, active2, 0L, active3, 0x1e0000000000L, active4, 0xcL, active5, 0x400004011800L, active6, 0x80000000000000L, active7, 0x80820000000ff000L, active8, 0L, active9, 0x400L, active10, 0x200000000700000L, active11, 0L); + case 86: + case 118: + if ((active6 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(3, 427, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x80000000000L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x2000L, active6, 0x400000000000L, active7, 0x600000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x10L); + case 87: + case 119: + if ((active8 & 0x1L) != 0L) + return jjStartNfaWithStates_2(3, 512, 88); + else if ((active10 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(3, 670, 88); + return jjMoveStringLiteralDfa4_2(active0, 0x40000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active5 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(3, 375, 88); + return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x20000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000L, active10, 0x8000000L, active11, 0L); + default : + break; + } + return jjStartNfa_2(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa4_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(2, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 4; + } + switch(curChar) + { + case 50: + if ((active10 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(4, 659, 88); + break; + case 54: + if ((active10 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(4, 658, 88); + break; + case 95: + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x10000000000004L, active2, 0L, active3, 0x1000000L, active4, 0x80401fc00000L, active5, 0L, active6, 0xf800000000000000L, active7, 0xfL, active8, 0L, active9, 0x80000000000000L, active10, 0x10000000000f000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa5_2(active0, 0x180000000000000L, active1, 0x200063e03f8L, active2, 0x2000008000L, active3, 0x401000100240L, active4, 0x80002000000400c0L, active5, 0x10c00002038L, active6, 0x120000020000L, active7, 0x1000010000004e0L, active8, 0x8000L, active9, 0x1000000000000100L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active5 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(4, 348, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0x20L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1000000L, active8, 0x1f0000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active11 & 0x40L) != 0L) + return jjStartNfaWithStates_2(4, 710, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x2000L, active1, 0L, active2, 0L, active3, 0x4000000000000000L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0x8200080000000L, active8, 0x600080L, active9, 0x200000000000400L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(4, 215, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x2000000000000L, active1, 0L, active2, 0x10000000002000L, active3, 0xc0000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active1 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(4, 78, 88); + else if ((active2 & 0x8L) != 0L) + return jjStartNfaWithStates_2(4, 131, 88); + else if ((active3 & 0x400L) != 0L) + return jjStartNfaWithStates_2(4, 202, 88); + else if ((active3 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 245, 88); + else if ((active4 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(4, 292, 88); + else if ((active5 & 0x4L) != 0L) + return jjStartNfaWithStates_2(4, 322, 88); + else if ((active5 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(4, 358, 88); + else if ((active6 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 434, 88); + else if ((active7 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(4, 470, 88); + else if ((active7 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(4, 485, 88); + else if ((active7 & 0x10000000000L) != 0L) + { + jjmatchedKind = 488; + jjmatchedPos = 4; + } + else if ((active8 & 0x100L) != 0L) + return jjStartNfaWithStates_2(4, 520, 88); + else if ((active9 & 0x8L) != 0L) + { + jjmatchedKind = 579; + jjmatchedPos = 4; + } + else if ((active9 & 0x800L) != 0L) + return jjStartNfaWithStates_2(4, 587, 88); + else if ((active9 & 0x1000000L) != 0L) + { + jjmatchedKind = 600; + jjmatchedPos = 4; + } + else if ((active10 & 0x400L) != 0L) + return jjStartNfaWithStates_2(4, 650, 88); + else if ((active10 & 0x100000L) != 0L) + { + jjmatchedKind = 660; + jjmatchedPos = 4; + } + else if ((active10 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(4, 674, 88); + else if ((active10 & 0x40000000000L) != 0L) + { + jjmatchedKind = 682; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_2(active0, 0x20840000000000L, active1, 0xffe0280700408000L, active2, 0x42000002800001L, active3, 0x2100000402001000L, active4, 0x20000L, active5, 0x4080000000202L, active6, 0x84c00f400000L, active7, 0x6800e0000000200L, active8, 0L, active9, 0x6f440d0L, active10, 0x2e0000200600000L, active11, 0L); + case 70: + case 102: + if ((active2 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(4, 155, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0L, active5, 0x8000L, active6, 0L, active7, 0L, active8, 0x4000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active10 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(4, 656, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x20000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x200L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(4, 154, 88); + else if ((active2 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 185, 88); + else if ((active3 & 0x800L) != 0L) + return jjStartNfaWithStates_2(4, 203, 88); + else if ((active4 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 313; + jjmatchedPos = 4; + } + else if ((active5 & 0x20000L) != 0L) + { + jjmatchedKind = 337; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x3c00000000000000L, active5, 0x40000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x804000000L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa5_2(active0, 0x4040000700000000L, active1, 0x400f8000000L, active2, 0xc000000000L, active3, 0x8000000000200000L, active4, 0x20000000001L, active5, 0x20020100100L, active6, 0x1410480058000L, active7, 0x182100043c000000L, active8, 0x1fff8000e00L, active9, 0x1000000020L, active10, 0x401000403a000000L, active11, 0x18L); + case 75: + case 107: + if ((active1 & 0x400L) != 0L) + return jjStartNfaWithStates_2(4, 74, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000L, active5, 0L, active6, 0L, active7, 0x100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 76: + case 108: + if ((active1 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(4, 80, 88); + else if ((active3 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(4, 205, 88); + else if ((active4 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(4, 289, 88); + else if ((active4 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(4, 300, 88); + else if ((active4 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 306; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_2(active0, 0x1800000000000040L, active1, 0L, active2, 0x400020800000800L, active3, 0L, active4, 0x18000000000000L, active5, 0x10000L, active6, 0x30L, active7, 0x100000001000L, active8, 0xe0000000026L, active9, 0x40000c000001000L, active10, 0x1002000000000000L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa5_2(active0, 0x40000000L, active1, 0x1800000L, active2, 0xe00000004000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0x7f00L, active7, 0xc000000000L, active8, 0L, active9, 0x4000000000000000L, active10, 0x20L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x400L) != 0L) + return jjStartNfaWithStates_2(4, 10, 88); + else if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 4; + } + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_2(4, 64, 88); + else if ((active10 & 0x2L) != 0L) + return jjStartNfaWithStates_2(4, 641, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x98000000020L, active1, 0L, active2, 0x400700000L, active3, 0x200000000080L, active4, 0x10L, active5, 0x4000000000000000L, active6, 0L, active7, 0xc00100000000L, active8, 0xf00000000000L, active9, 0x8000000000000200L, active10, 0x2008000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa5_2(active0, 0x20800000080L, active1, 0L, active2, 0x1000000006L, active3, 0x40040000L, active4, 0x10000L, active5, 0x6000000020000c0L, active6, 0x10000000L, active7, 0L, active8, 0L, active9, 0x8000000L, active10, 0x9000000008L, active11, 0L); + case 80: + case 112: + if ((active3 & 0x20000000000L) != 0L) + { + jjmatchedKind = 233; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0xd100000000000000L, active3, 0x1c0000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x800000000L, active8, 0L, active9, 0L, active10, 0x20000800000L, active11, 0L); + case 82: + case 114: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_2(4, 11, 88); + else if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(4, 15, 88); + else if ((active2 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 187, 88); + else if ((active3 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(4, 209, 88); + else if ((active4 & 0x2L) != 0L) + return jjStartNfaWithStates_2(4, 257, 88); + else if ((active4 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 310, 88); + else if ((active5 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(4, 347, 88); + else if ((active5 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 380; + jjmatchedPos = 4; + } + else if ((active6 & 0x2L) != 0L) + return jjStartNfaWithStates_2(4, 385, 88); + else if ((active6 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(4, 421, 88); + else if ((active6 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(4, 429, 88); + else if ((active10 & 0x1L) != 0L) + return jjStartNfaWithStates_2(4, 640, 88); + else if ((active10 & 0x100L) != 0L) + return jjStartNfaWithStates_2(4, 648, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x102010000000L, active1, 0x1800000000000L, active2, 0x3c00c0000L, active3, 0x210000300400100L, active4, 0x8000001c20L, active5, 0xa000500004000000L, active6, 0x680000000000040L, active7, 0x420000000fe800L, active8, 0x1000000000000L, active9, 0L, active10, 0x200L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 114, 88); + else if ((active3 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 242, 88); + else if ((active5 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(4, 341, 88); + else if ((active5 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(4, 343, 88); + else if ((active5 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(4, 362, 88); + else if ((active6 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 437, 88); + else if ((active7 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 511, 88); + else if ((active10 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(4, 685, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x8000000L, active1, 0x1800L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1000000L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x1ff0380000000L, active10, 0x1000040L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(4, 110, 88); + else if ((active3 & 0x4000L) != 0L) + { + jjmatchedKind = 206; + jjmatchedPos = 4; + } + else if ((active3 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(4, 208, 88); + else if ((active3 & 0x8000000000L) != 0L) + { + jjmatchedKind = 231; + jjmatchedPos = 4; + } + else if ((active4 & 0x4L) != 0L) + return jjStartNfaWithStates_2(4, 258, 88); + else if ((active4 & 0x8L) != 0L) + return jjStartNfaWithStates_2(4, 259, 88); + else if ((active4 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 304, 88); + else if ((active6 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(4, 414, 88); + else if ((active7 & 0x100L) != 0L) + return jjStartNfaWithStates_2(4, 456, 88); + else if ((active7 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(4, 469, 88); + else if ((active9 & 0x4L) != 0L) + return jjStartNfaWithStates_2(4, 578, 88); + else if ((active9 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 625, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x201f800000000L, active2, 0x1000180L, active3, 0x8010020008010L, active4, 0x20080100000000L, active5, 0x1800000001800L, active6, 0x2001800080000L, active7, 0x10L, active8, 0x7ffc000000004000L, active9, 0x38000L, active10, 0x80L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa5_2(active0, 0x8000000000000000L, active1, 0L, active2, 0x30000L, active3, 0x180000000000000bL, active4, 0x800000000L, active5, 0x1L, active6, 0x20000004L, active7, 0x2000000L, active8, 0L, active9, 0x2000000000002000L, active10, 0x4000000000004L, active11, 0x20L); + case 86: + case 118: + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0x10000000L, active3, 0L, active4, 0L, active5, 0x2000000000L, active6, 0L, active7, 0L, active8, 0x8000000000000000L, active9, 0x1L, active10, 0x10L, active11, 0L); + case 87: + case 119: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(4, 14, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0x1L); + case 88: + case 120: + if ((active10 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 699, 88); + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(4, 19, 88); + else if ((active0 & 0x200000L) != 0L) + { + jjmatchedKind = 21; + jjmatchedPos = 4; + } + else if ((active2 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 179, 88); + else if ((active2 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(4, 189, 88); + else if ((active11 & 0x80L) != 0L) + return jjStartNfaWithStates_2(4, 711, 88); + return jjMoveStringLiteralDfa5_2(active0, 0x1c10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x400000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc00000000L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_2(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa5_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(3, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 5; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa6_2(active0, 0x18001c00000L, active1, 0x1800000001000L, active2, 0x2000000L, active3, 0x40002008000L, active4, 0x3000000000000000L, active5, 0x800000000000L, active6, 0L, active7, 0xe0000000000L, active8, 0L, active9, 0x2000000L, active10, 0x2e0000800400000L, active11, 0L); + case 65: + case 97: + if ((active7 & 0x4000000000L) != 0L) + { + jjmatchedKind = 486; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_2(active0, 0x800000002000L, active1, 0L, active2, 0x100000000004020L, active3, 0xc000000300400000L, active4, 0x8800c20001L, active5, 0x4000002004000000L, active6, 0x1800000000008030L, active7, 0x40008001000000L, active8, 0x8000000000804002L, active9, 0x2800f0000001001L, active10, 0x2000005000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa6_2(active0, 0x600000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x100000000L) != 0L) + { + jjmatchedKind = 32; + jjmatchedPos = 5; + } + else if ((active6 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 432, 88); + else if ((active9 & 0x20L) != 0L) + return jjStartNfaWithStates_2(5, 581, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x7004003f8L, active2, 0L, active3, 0x200L, active4, 0L, active5, 0L, active6, 0x2000000000000000L, active7, 0x280L, active8, 0x300000002000L, active9, 0L, active10, 0x10000000000000L, active11, 0x10L); + case 68: + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 53, 88); + else if ((active3 & 0x80L) != 0L) + return jjStartNfaWithStates_2(5, 199, 88); + else if ((active5 & 0x40L) != 0L) + return jjStartNfaWithStates_2(5, 326, 88); + else if ((active6 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(5, 412, 88); + else if ((active7 & 0x400000000000L) != 0L) + { + jjmatchedKind = 494; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_2(active0, 0x180000000000000L, active1, 0x10000000000000L, active2, 0L, active3, 0x1800000000000003L, active4, 0L, active5, 0L, active6, 0x80c000000000L, active7, 0x800000000000L, active8, 0L, active9, 0x8000000000000000L, active10, 0xf000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(5, 37, 88); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 113, 88); + else if ((active2 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(5, 141, 88); + else if ((active2 & 0x100000L) != 0L) + { + jjmatchedKind = 148; + jjmatchedPos = 5; + } + else if ((active2 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(5, 151, 88); + else if ((active2 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(5, 152, 88); + else if ((active2 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(5, 169, 88); + else if ((active2 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 188, 88); + else if ((active3 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 244, 88); + else if ((active5 & 0x800L) != 0L) + { + jjmatchedKind = 331; + jjmatchedPos = 5; + } + else if ((active5 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(5, 336, 88); + else if ((active7 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(5, 468, 88); + else if ((active8 & 0x4L) != 0L) + return jjStartNfaWithStates_2(5, 514, 88); + else if ((active8 & 0x80L) != 0L) + return jjStartNfaWithStates_2(5, 519, 88); + else if ((active9 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 634, 88); + else if ((active10 & 0x4L) != 0L) + return jjStartNfaWithStates_2(5, 642, 88); + else if ((active10 & 0x80L) != 0L) + return jjStartNfaWithStates_2(5, 647, 88); + return jjMoveStringLiteralDfa6_2(active0, 0x40040000000L, active1, 0L, active2, 0x10600000L, active3, 0x10000000000L, active4, 0xc00000081004200L, active5, 0x1001000L, active6, 0x602000000007f00L, active7, 0L, active8, 0x1000001000000L, active9, 0x3c004000040000L, active10, 0x2000020000000020L, active11, 0L); + case 70: + case 102: + if ((active5 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(5, 361, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe00L, active9, 0x300000000000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active3 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(5, 237, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x200000L, active4, 0L, active5, 0x38L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active4 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(5, 299, 88); + else if ((active7 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(5, 493, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x200000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa6_2(active0, 0x8000000L, active1, 0x20000000800L, active2, 0x10e001c0000180L, active3, 0xc8080020000040L, active4, 0L, active5, 0x2000100000008000L, active6, 0x4000001800000040L, active7, 0x2000000000810L, active8, 0x1c000000070020L, active9, 0x8000008000L, active10, 0x8000000000000L, active11, 0L); + case 76: + case 108: + if ((active3 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(5, 228, 88); + else if ((active6 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(5, 401, 88); + else if ((active7 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(5, 492, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x4L, active2, 0x800030000L, active3, 0L, active4, 0x8000000000000000L, active5, 0xc00002000L, active6, 0x400000000000L, active7, 0x100000000000000L, active8, 0x4480000L, active9, 0x1c00000002000L, active10, 0x1000000000000000L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100L) != 0L) + return jjStartNfaWithStates_2(5, 584, 88); + else if ((active9 & 0x200000L) != 0L) + { + jjmatchedKind = 597; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x2100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x4000000000c00010L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_2(5, 7, 88); + else if ((active1 & 0x800000L) != 0L) + { + jjmatchedKind = 87; + jjmatchedPos = 5; + } + else if ((active2 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(5, 167, 88); + else if ((active3 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(5, 222, 88); + else if ((active5 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 377; + jjmatchedPos = 5; + } + else if ((active7 & 0x2000L) != 0L) + { + jjmatchedKind = 461; + jjmatchedPos = 5; + } + else if ((active10 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(5, 678, 88); + return jjMoveStringLiteralDfa6_2(active0, 0x4040000020000000L, active1, 0xffe0040007000000L, active2, 0x2005000000001L, active3, 0x100L, active4, 0x200000000c0L, active5, 0x400000022000200L, active6, 0x8f040000L, active7, 0x8000043c0fc000L, active8, 0x1fff8000000L, active9, 0x2000001000000000L, active10, 0x400000000a000000L, active11, 0x8L); + case 79: + case 111: + return jjMoveStringLiteralDfa6_2(active0, 0x1800000000000000L, active1, 0L, active2, 0x400000800L, active3, 0L, active4, 0x20000006000000L, active5, 0L, active6, 0x400000000L, active7, 0x1801000880000000L, active8, 0xe0002100000L, active9, 0xc00000000L, active10, 0x30800010L, active11, 0x1L); + case 80: + case 112: + if ((active7 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(5, 473, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000000000L, active10, 0x404000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x2L) != 0L) + { + jjmatchedKind = 129; + jjmatchedPos = 5; + } + else if ((active3 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(5, 204, 88); + else if ((active5 & 0x2L) != 0L) + return jjStartNfaWithStates_2(5, 321, 88); + else if ((active5 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(5, 363, 88); + else if ((active7 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(5, 484, 88); + else if ((active7 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 505; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_2(active0, 0x8000000800000000L, active1, 0x9f800000000L, active2, 0x800000000c8004L, active3, 0x400000000000L, active4, 0xa00000000000L, active5, 0x400000000001L, active6, 0x8000160000400000L, active7, 0x400000000000400L, active8, 0x8000L, active9, 0x8030000L, active10, 0x100000000000000L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(5, 16, 88); + else if ((active2 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 186, 88); + else if ((active3 & 0x10L) != 0L) + return jjStartNfaWithStates_2(5, 196, 88); + else if ((active3 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(5, 236, 88); + else if ((active5 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(5, 338, 88); + else if ((active5 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 368, 88); + else if ((active5 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 383, 88); + else if ((active10 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(5, 661, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x200000008000L, active2, 0L, active3, 0x1000000L, active4, 0xc10L, active5, 0x100180L, active6, 0x80010000000000L, active7, 0x2fL, active8, 0x7fe0000000000000L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_2(5, 5, 88); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(5, 43, 88); + else if ((active1 & 0x8000000L) != 0L) + { + jjmatchedKind = 91; + jjmatchedPos = 5; + } + else if ((active2 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 190; + jjmatchedPos = 5; + } + else if ((active3 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(5, 212, 88); + else if ((active3 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 249, 88); + else if ((active4 & 0x20L) != 0L) + return jjStartNfaWithStates_2(5, 261, 88); + else if ((active5 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(5, 365, 88); + else if ((active5 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 370, 88); + else if ((active6 & 0x4L) != 0L) + return jjStartNfaWithStates_2(5, 386, 88); + else if ((active7 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(5, 460, 88); + else if ((active7 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(5, 499, 88); + else if ((active9 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(5, 590, 88); + else if ((active10 & 0x40L) != 0L) + return jjStartNfaWithStates_2(5, 646, 88); + else if ((active10 & 0x200L) != 0L) + return jjStartNfaWithStates_2(5, 649, 88); + return jjMoveStringLiteralDfa6_2(active0, 0x2000010000000L, active1, 0xf03e0000L, active2, 0x8000002000000000L, active3, 0x400000008L, active4, 0x18000000040000L, active5, 0L, active6, 0x20010000L, active7, 0x20000000000040L, active8, 0L, active9, 0x380100400L, active10, 0L, active11, 0x20L); + case 85: + case 117: + return jjMoveStringLiteralDfa6_2(active0, 0x20000000040L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0x400000000000L, active9, 0L, active10, 0x8000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010001000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0xc0L, active10, 0x200000000L, active11, 0L); + case 87: + case 119: + if ((active4 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(5, 272, 88); + else if ((active10 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(5, 676, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x40000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(5, 44, 88); + return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_2(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa6_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(4, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 6; + } + switch(curChar) + { + case 50: + if ((active6 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 447, 88); + break; + case 95: + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0xc002c0L, active10, 0x2000000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa7_2(active0, 0x40000000400000L, active1, 0xf800000000L, active2, 0x80000000040000L, active3, 0xc0000000000100L, active4, 0x4010001000L, active5, 0x2000000L, active6, 0L, active7, 0x40L, active8, 0x3800000200000L, active9, 0x1c0038c000000L, active10, 0x2000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0x40000000L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x800000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x200000000000L) != 0L) + { + jjmatchedKind = 173; + jjmatchedPos = 6; + } + else if ((active5 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(6, 364, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x800000L, active1, 0x8000L, active2, 0xc06000000800L, active3, 0x440000000000L, active4, 0x40L, active5, 0x1000000L, active6, 0L, active7, 0x80020001000800L, active8, 0x1000000L, active9, 0xf0000000000L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active2 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(6, 149, 88); + else if ((active2 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(6, 156, 88); + else if ((active3 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(6, 232, 88); + else if ((active4 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 314, 88); + else if ((active10 & 0x20L) != 0L) + return jjStartNfaWithStates_2(6, 645, 88); + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x6000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x40L, active7, 0L, active8, 0L, active9, 0x2000000000040000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 6; + } + else if ((active1 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(6, 81, 88); + else if ((active2 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(6, 143, 88); + else if ((active3 & 0x1L) != 0L) + return jjStartNfaWithStates_2(6, 192, 88); + else if ((active3 & 0x8L) != 0L) + return jjStartNfaWithStates_2(6, 195, 88); + else if ((active3 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 251, 88); + else if ((active6 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(6, 413, 88); + else if ((active6 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(6, 425, 88); + else if ((active7 & 0x20L) != 0L) + return jjStartNfaWithStates_2(6, 453, 88); + else if ((active7 & 0x80L) != 0L) + return jjStartNfaWithStates_2(6, 455, 88); + else if ((active7 & 0x4000000L) != 0L) + { + jjmatchedKind = 474; + jjmatchedPos = 6; + } + else if ((active9 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 636, 88); + else if ((active11 & 0x10L) != 0L) + return jjStartNfaWithStates_2(6, 708, 88); + else if ((active11 & 0x20L) != 0L) + return jjStartNfaWithStates_2(6, 709, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x100000000000000L, active1, 0x4L, active2, 0x40000000080000L, active3, 0x2100000001000000L, active4, 0x800000000c00L, active5, 0x4000001081b9L, active6, 0x404000000000L, active7, 0x3803c000L, active8, 0x2000L, active9, 0x10L, active10, 0x110000020000f000L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa7_2(active0, 0x8000000000L, active1, 0x800L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 59; + jjmatchedPos = 6; + } + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 62, 88); + else if ((active4 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(6, 297, 88); + else if ((active5 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(6, 349, 88); + else if ((active6 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(6, 402, 88); + else if ((active6 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(6, 415, 88); + else if ((active7 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(6, 482, 88); + else if ((active10 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(6, 667, 88); + else if ((active10 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 702, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x1000000000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 49, 88); + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x100000000000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa7_2(active0, 0x810000000L, active1, 0x100000e03c0000L, active2, 0x8000000200000000L, active3, 0x1000000000040002L, active4, 0x18000000040010L, active5, 0xc00000000L, active6, 0x80018000010000L, active7, 0x120000800040000L, active8, 0x7fe0000000000e00L, active9, 0xc000000000030000L, active10, 0x8010000000000000L, active11, 0L); + case 76: + case 108: + if ((active2 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(6, 142, 88); + else if ((active3 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(6, 224, 88); + else if ((active3 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 255; + jjmatchedPos = 6; + } + else if ((active4 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(6, 295, 88); + else if ((active5 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(6, 346, 88); + else if ((active6 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(6, 399, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x20000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1L, active5, 0x4000812000000000L, active6, 0L, active7, 0x1L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa7_2(active0, 0x21000000L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0xc400000000000L, active9, 0L, active10, 0x1000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(6, 42, 88); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(6, 47, 88); + else if ((active3 & 0x40L) != 0L) + return jjStartNfaWithStates_2(6, 198, 88); + else if ((active3 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(6, 213, 88); + else if ((active3 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(6, 214, 88); + else if ((active6 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(6, 406, 88); + else if ((active6 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(6, 418, 88); + else if ((active7 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 496, 88); + else if ((active7 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 507; + jjmatchedPos = 6; + } + else if ((active10 & 0x8L) != 0L) + return jjStartNfaWithStates_2(6, 643, 88); + else if ((active10 & 0x10000000L) != 0L) + { + jjmatchedKind = 668; + jjmatchedPos = 6; + } + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x20000000000L, active2, 0x10001000000000L, active3, 0x80000000000L, active4, 0x1000000000000000L, active5, 0x2000000000000200L, active6, 0x4600000000000000L, active7, 0x1000040000000000L, active8, 0x100e0000028020L, active9, 0x8c02000000L, active10, 0x80000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1000L, active2, 0x800000000L, active3, 0x20000000L, active4, 0L, active5, 0L, active6, 0x2000001800000000L, active7, 0L, active8, 0x4580000L, active9, 0x300000000000L, active10, 0x400000L, active11, 0L); + case 80: + case 112: + if ((active10 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(6, 663, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x10000000000L, active1, 0xa00000000000L, active2, 0x180000000L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0x10L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(6, 150, 88); + else if ((active4 & 0x200L) != 0L) + return jjStartNfaWithStates_2(6, 265, 88); + else if ((active4 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(6, 270, 88); + else if ((active4 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(6, 273, 88); + else if ((active4 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 309, 88); + else if ((active6 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 433, 88); + else if ((active8 & 0x2L) != 0L) + return jjStartNfaWithStates_2(6, 513, 88); + else if ((active9 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 626; + jjmatchedPos = 6; + } + else if ((active10 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(6, 666, 88); + else if ((active10 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(6, 681, 88); + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0x100000002000000L, active3, 0x402000000L, active4, 0x2000000000c00000L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x8000000000000000L, active9, 0xb8000000100001L, active10, 0L, active11, 0x1L); + case 83: + case 115: + if ((active4 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 315, 88); + else if ((active5 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(6, 332, 88); + else if ((active5 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 378, 88); + else if ((active7 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(6, 467, 88); + else if ((active7 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(6, 495, 88); + else if ((active10 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 690, 88); + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1000000000000L, active2, 0x400000020L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0L, active9, 0x1000L, active10, 0x20000000000000L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(6, 86, 88); + else if ((active1 & 0x100000000L) != 0L) + { + jjmatchedKind = 96; + jjmatchedPos = 6; + } + else if ((active1 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(6, 107, 88); + else if ((active1 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 117; + jjmatchedPos = 6; + } + else if ((active2 & 0x10000L) != 0L) + { + jjmatchedKind = 144; + jjmatchedPos = 6; + } + else if ((active2 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 177, 88); + else if ((active3 & 0x200L) != 0L) + return jjStartNfaWithStates_2(6, 201, 88); + else if ((active6 & 0x1000000L) != 0L) + { + jjmatchedKind = 408; + jjmatchedPos = 6; + } + else if ((active7 & 0x200L) != 0L) + return jjStartNfaWithStates_2(6, 457, 88); + else if ((active7 & 0x400L) != 0L) + return jjStartNfaWithStates_2(6, 458, 88); + else if ((active8 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(6, 530, 88); + else if ((active9 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(6, 612, 88); + else if ((active10 & 0x10L) != 0L) + return jjStartNfaWithStates_2(6, 644, 88); + else if ((active10 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(6, 679, 88); + return jjMoveStringLiteralDfa7_2(active0, 0x48002040L, active1, 0xffc00006100003f8L, active2, 0x20001L, active3, 0x4008000200000000L, active4, 0x80L, active5, 0L, active6, 0xe007f00L, active7, 0x42000000000000L, active8, 0x1fff8804000L, active9, 0x20000000000a000L, active10, 0x60a000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa7_2(active0, 0x600000000L, active1, 0x50000000000L, active2, 0L, active3, 0L, active4, 0x8000000008000000L, active5, 0x2000L, active6, 0x800000000000L, active7, 0x80000000L, active8, 0x2000000L, active9, 0x400L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0x1800040000000000L, active7, 0x10L, active8, 0L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x6L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(6, 63, 88); + else if ((active4 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(6, 301, 88); + else if ((active6 & 0x20L) != 0L) + return jjStartNfaWithStates_2(6, 389, 88); + else if ((active6 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(6, 428, 88); + return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_2(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa7_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(5, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 7; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa8_2(active0, 0x1000000000000000L, active1, 0xffc0000006000000L, active2, 0xc00000000001L, active3, 0L, active4, 0L, active5, 0x38L, active6, 0x8000000L, active7, 0x1000000038000000L, active8, 0x7fe0000000000000L, active9, 0x38000000000000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa8_2(active0, 0x10001000000L, active1, 0x1000000000000L, active2, 0x2000800L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x60000000000L, active8, 0x100004020000L, active9, 0x2000200L, active10, 0x80000000000000L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(7, 531, 88); + else if ((active8 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(7, 534, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000040L, active8, 0x8000000002000000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 182, 90); + else if ((active8 & 0x200L) != 0L) + { + jjmatchedKind = 521; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x10000000000L, active2, 0L, active3, 0x1000000L, active4, 0xc00L, active5, 0x180L, active6, 0x600000000000000L, active7, 0x80000000000L, active8, 0xc00L, active9, 0x1L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 56, 88); + else if ((active2 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(7, 147, 88); + else if ((active11 & 0x1L) != 0L) + return jjStartNfaWithStates_2(7, 704, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x40L) != 0L) + return jjStartNfaWithStates_2(7, 6, 88); + else if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(7, 13, 88); + else if ((active1 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(7, 79, 88); + else if ((active1 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(7, 106, 88); + else if ((active2 & 0x20L) != 0L) + return jjStartNfaWithStates_2(7, 133, 88); + else if ((active2 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(7, 158, 88); + else if ((active4 & 0x40L) != 0L) + return jjStartNfaWithStates_2(7, 262, 88); + else if ((active4 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(7, 288, 88); + else if ((active4 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(7, 291, 88); + else if ((active4 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 319, 88); + else if ((active5 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(7, 333, 88); + else if ((active5 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(7, 360, 88); + else if ((active6 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(7, 426, 88); + else if ((active7 & 0x10L) != 0L) + return jjStartNfaWithStates_2(7, 452, 88); + else if ((active7 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 503, 88); + else if ((active8 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(7, 526, 88); + else if ((active8 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(7, 535, 88); + else if ((active8 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 562; + jjmatchedPos = 7; + } + else if ((active9 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 633, 88); + else if ((active10 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 689, 88); + return jjMoveStringLiteralDfa8_2(active0, 0x20000000L, active1, 0x100003f8L, active2, 0x1000000180L, active3, 0x200000000L, active4, 0x2000000008000000L, active5, 0x800000000000L, active6, 0x7f00L, active7, 0L, active8, 0x841fff8000000L, active9, 0x2000004c00000000L, active10, 0x400000000000000L, active11, 0L); + case 70: + case 102: + if ((active10 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(7, 662, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L, active11, 0L); + case 71: + case 103: + if ((active2 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 180, 88); + else if ((active3 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(7, 235, 88); + else if ((active5 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 381, 88); + else if ((active9 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(7, 615, 88); + return jjMoveStringLiteralDfa8_2(active0, 0x400000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000000L, active5, 0L, active6, 0x1800400000000000L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0x100000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(7, 165, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x400000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa8_2(active0, 0x8000000L, active1, 0xfe00000800L, active2, 0L, active3, 0L, active4, 0x1000080L, active5, 0x4000000000000200L, active6, 0x6000040L, active7, 0L, active8, 0x1018000L, active9, 0x102000L, active10, 0x20000000L, active11, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active7 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(7, 472, 88); + break; + case 76: + case 108: + if ((active3 & 0x100L) != 0L) + return jjStartNfaWithStates_2(7, 200, 88); + else if ((active4 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(7, 268, 88); + else if ((active5 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(7, 345, 88); + else if ((active8 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 560, 88); + else if ((active10 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 700, 88); + return jjMoveStringLiteralDfa8_2(active0, 0x40020000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010000001L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000100000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0x18000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x384000000L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active3 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(7, 221, 88); + else if ((active6 & 0x800000000L) != 0L) + { + jjmatchedKind = 419; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x1000004L, active2, 0x200000004L, active3, 0x3100000000040002L, active4, 0L, active5, 0x400000000000L, active6, 0x9000000000L, active7, 0x400008880040000L, active8, 0L, active9, 0x30010L, active10, 0x8000000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa8_2(active0, 0x10800000L, active1, 0xa000e03c0000L, active2, 0x8000000000000000L, active3, 0x4000040002000000L, active4, 0x40000L, active5, 0x1000000L, active6, 0x10000090000L, active7, 0x40000000000001L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0x8L); + case 80: + case 112: + if ((active10 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(7, 664, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0x40L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active8 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(7, 533, 88); + else if ((active10 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(7, 673, 88); + return jjMoveStringLiteralDfa8_2(active0, 0x8040000000L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0xc00000L, active5, 0L, active6, 0x800000000000L, active7, 0L, active8, 0x800000000000L, active9, 0x80300008000400L, active10, 0x40000002000000L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(7, 105, 88); + else if ((active2 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(7, 145, 88); + else if ((active5 & 0x1L) != 0L) + return jjStartNfaWithStates_2(7, 320, 88); + else if ((active5 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(7, 335, 88); + else if ((active6 & 0x10L) != 0L) + return jjStartNfaWithStates_2(7, 388, 88); + else if ((active6 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(7, 422, 88); + else if ((active9 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(7, 594, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x10000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1080L, active10, 0x2000000000000000L, active11, 0L); + case 84: + case 116: + if ((active2 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(7, 166, 88); + else if ((active5 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(7, 340, 88); + else if ((active7 & 0x800L) != 0L) + return jjStartNfaWithStates_2(7, 459, 88); + else if ((active8 & 0x20L) != 0L) + return jjStartNfaWithStates_2(7, 517, 88); + return jjMoveStringLiteralDfa8_2(active0, 0x600000000L, active1, 0L, active2, 0x100000580000000L, active3, 0xc0000000000000L, active4, 0x10L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0xc001cf0000400000L, active10, 0x10000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0x2000000000L, active6, 0x2000000000000000L, active7, 0L, active8, 0L, active9, 0x808000L, active10, 0x800000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000000000000L, active7, 0x20000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active2 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(7, 163, 88); + break; + case 88: + case 120: + if ((active7 & 0x2L) != 0L) + return jjStartNfaWithStates_2(7, 449, 88); + break; + case 89: + case 121: + if ((active3 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(7, 226, 88); + else if ((active3 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 243, 88); + else if ((active7 & 0x4L) != 0L) + return jjStartNfaWithStates_2(7, 450, 88); + else if ((active7 & 0x8L) != 0L) + return jjStartNfaWithStates_2(7, 451, 88); + else if ((active7 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(7, 497, 88); + return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000000000000L, active9, 0L, active10, 0x228000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa8_2(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0xc00000000L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_2(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa8_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(6, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000000000L, active7, 0x3c000L, active8, 0x400L, active9, 0xc00001000L, active10, 0x8000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa9_2(active0, 0x8800000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0xc00080L, active5, 0L, active6, 0L, active7, 0x500008000000000L, active8, 0L, active9, 0x80000000000080L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(8, 557, 88); + break; + case 67: + case 99: + if ((active9 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(8, 596, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x40000000000000L, active2, 0x1000000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0x400000000000L, active6, 0L, active7, 0x8000000L, active8, 0x800000000000L, active9, 0x8000000000000L, active10, 0x800000000L, active11, 0L); + case 68: + case 100: + if ((active1 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(8, 92, 88); + else if ((active3 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(8, 225, 88); + else if ((active9 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 637, 88); + else if ((active10 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 698, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x180000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000L) != 0L) + { + jjmatchedKind = 33; + jjmatchedPos = 8; + } + else if ((active2 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 183, 88); + else if ((active3 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 246; + jjmatchedPos = 8; + } + else if ((active4 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 307; + jjmatchedPos = 8; + } + else if ((active5 & 0x400000000L) != 0L) + { + jjmatchedKind = 354; + jjmatchedPos = 8; + } + else if ((active5 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(8, 357, 88); + else if ((active6 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(8, 431, 88); + else if ((active6 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 439, 88); + else if ((active7 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 501, 88); + else if ((active9 & 0x400L) != 0L) + return jjStartNfaWithStates_2(8, 586, 88); + else if ((active9 & 0x400000000000L) != 0L) + { + jjmatchedKind = 622; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_2(active0, 0x400000000L, active1, 0x800L, active2, 0L, active3, 0x80000000000000L, active4, 0x10800086000000L, active5, 0x800000000L, active6, 0x4200400000000000L, active7, 0x100000000L, active8, 0x100000L, active9, 0x800000000000L, active10, 0L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(8, 22, 88); + else if ((active3 & 0x2L) != 0L) + return jjStartNfaWithStates_2(8, 193, 88); + else if ((active3 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(8, 210, 88); + else if ((active3 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 252, 88); + else if ((active6 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(8, 423, 88); + else if ((active7 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(8, 466, 88); + else if ((active9 & 0x10000L) != 0L) + { + jjmatchedKind = 592; + jjmatchedPos = 8; + } + else if ((active10 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 703, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x4L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000L, active9, 0x20200L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0x80000000000000L, active9, 0x1L, active10, 0L, active11, 0L); + case 73: + case 105: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(8, 41, 88); + return jjMoveStringLiteralDfa9_2(active0, 0x40000040000000L, active1, 0x1000L, active2, 0x100000680000000L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000000L, active9, 0x80010f0000400000L, active10, 0x210000000000f000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0x8000L, active4, 0L, active5, 0x8L, active6, 0x6000000L, active7, 0x40L, active8, 0x2000002000000L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100000000000L) != 0L) + { + jjmatchedKind = 620; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x1000000000000L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0L, active7, 0x40000000000L, active8, 0x700000001000000L, active9, 0x200002000000L, active10, 0x80000000000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(8, 28, 88); + else if ((active1 & 0x40000L) != 0L) + { + jjmatchedKind = 82; + jjmatchedPos = 8; + } + else if ((active1 & 0x20000000L) != 0L) + { + jjmatchedKind = 93; + jjmatchedPos = 8; + } + else if ((active2 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 191, 88); + else if ((active4 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(8, 274, 88); + else if ((active6 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(8, 400, 88); + else if ((active6 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(8, 424, 88); + return jjMoveStringLiteralDfa9_2(active0, 0x1000000020800000L, active1, 0x20f8c0380000L, active2, 0x2000000L, active3, 0x40000000000L, active4, 0L, active5, 0x800001000000L, active6, 0x2000000000000040L, active7, 0x10000000L, active8, 0x18000L, active9, 0x10000000000000L, active10, 0x20000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x600000000L, active2, 0x100000000L, active3, 0x1000000L, active4, 0L, active5, 0x190L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40L, active10, 0x40000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(8, 111, 88); + else if ((active9 & 0x80000000L) != 0L) + { + jjmatchedKind = 607; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x200000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1L, active8, 0L, active9, 0x304000000L, active10, 0x200000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 8; + } + else if ((active3 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 254, 88); + else if ((active6 & 0x100L) != 0L) + { + jjmatchedKind = 392; + jjmatchedPos = 8; + } + else if ((active7 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 502, 88); + else if ((active8 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_2(8, 556, 88); + return jjMoveStringLiteralDfa9_2(active0, 0x10000000000L, active1, 0xc000000000003f0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0x8007e00L, active7, 0L, active8, 0x41fff0020000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0x1008000000000000L, active9, 0x20000000802000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 116, 88); + else if ((active3 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 253, 88); + else if ((active4 & 0x400L) != 0L) + { + jjmatchedKind = 266; + jjmatchedPos = 8; + } + else if ((active7 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(8, 479, 88); + else if ((active7 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(8, 483, 88); + else if ((active8 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(8, 538, 88); + else if ((active9 & 0x10L) != 0L) + return jjStartNfaWithStates_2(8, 580, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0xe000010000000000L, active2, 0x800L, active3, 0x100000000000000L, active4, 0x800L, active5, 0x4000000000000020L, active6, 0L, active7, 0x20000000000L, active8, 0x2800L, active9, 0x4000000000008000L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x4010000000L, active5, 0x200L, active6, 0x80000L, active7, 0x1000000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa9_2(active0, 0x8000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active3 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(8, 217, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active6 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 443, 88); + return jjMoveStringLiteralDfa9_2(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active3 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(8, 238, 88); + else if ((active4 & 0x1L) != 0L) + return jjStartNfaWithStates_2(8, 256, 88); + else if ((active6 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 444, 88); + else if ((active9 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(8, 603, 88); + else if ((active10 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(8, 665, 88); + else if ((active10 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(8, 692, 88); + return jjMoveStringLiteralDfa9_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4000000000000000L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_2(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa9_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(7, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 9; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa10_2(active0, 0x1000000L, active1, 0x803800f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7e00L, active7, 0L, active8, 0L, active9, 0x804000020000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa10_2(active0, 0x1000000000000000L, active1, 0x2c0000040000000L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x8000000L, active7, 0x20018000000L, active8, 0x200e0001100000L, active9, 0x18000100000001L, active10, 0L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000080L, active5, 0L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(9, 30, 88); + return jjMoveStringLiteralDfa10_2(active0, 0x800000L, active1, 0x1000000000000000L, active2, 0x400000000L, active3, 0x40000000000L, active4, 0x6000000L, active5, 0x10L, active6, 0L, active7, 0x20004000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L, active11, 0L); + case 68: + case 100: + if ((active5 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(9, 344, 88); + else if ((active5 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(9, 355, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x200000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(9, 27, 88); + else if ((active2 & 0x800L) != 0L) + return jjStartNfaWithStates_2(9, 139, 88); + else if ((active2 & 0x40000L) != 0L) + return jjStartNfaWithStates_2(9, 146, 88); + else if ((active4 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(9, 284, 88); + else if ((active4 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(9, 294, 88); + else if ((active7 & 0x1L) != 0L) + return jjStartNfaWithStates_2(9, 448, 88); + else if ((active7 & 0x40L) != 0L) + return jjStartNfaWithStates_2(9, 454, 88); + else if ((active7 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(9, 490, 88); + else if ((active8 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(9, 537, 88); + else if ((active9 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(9, 591, 88); + else if ((active9 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(9, 601, 88); + else if ((active10 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 695, 88); + else if ((active10 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 697, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000028L, active6, 0x6000000L, active7, 0x80000000000L, active8, 0x7000000008000000L, active9, 0x4000000000802000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active6 & 0x40L) != 0L) + return jjStartNfaWithStates_2(9, 390, 88); + else if ((active8 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(9, 527, 88); + else if ((active9 & 0x200L) != 0L) + return jjStartNfaWithStates_2(9, 585, 88); + else if ((active10 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(9, 669, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x800000000000L, active6, 0x80000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0x400000000L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x6000000000000100L, active2, 0x180L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0L, active7, 0L, active8, 0x302400000002000L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active2 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(9, 153, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000800000000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x80000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active5 & 0x200L) != 0L) + return jjStartNfaWithStates_2(9, 329, 88); + return jjMoveStringLiteralDfa10_2(active0, 0x8000000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0x800400080L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active1 & 0x200000000L) != 0L) + { + jjmatchedKind = 97; + jjmatchedPos = 9; + } + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x400000000L, active2, 0L, active3, 0x1000000L, active4, 0L, active5, 0x180L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000400L, active9, 0L, active10, 0xf000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0xc00010000000000L, active2, 0x80000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x480000000000000L, active9, 0x80010f0000001000L, active10, 0x100000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 112, 88); + else if ((active9 & 0x40L) != 0L) + return jjStartNfaWithStates_2(9, 582, 88); + break; + case 82: + case 114: + if ((active1 & 0x800L) != 0L) + return jjStartNfaWithStates_2(9, 75, 88); + else if ((active2 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(9, 160, 88); + else if ((active4 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(9, 287, 88); + else if ((active7 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(9, 480, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000001000000000L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(9, 34, 88); + else if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_2(9, 73, 88); + else if ((active6 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(9, 430, 88); + else if ((active6 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 441, 88); + else if ((active9 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(9, 621, 88); + else if ((active11 & 0x8L) != 0L) + return jjStartNfaWithStates_2(9, 707, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0x200000001L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0L, active7, 0x1000000000020000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(9, 29, 88); + else if ((active1 & 0x800000000L) != 0L) + { + jjmatchedKind = 99; + jjmatchedPos = 9; + } + else if ((active2 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(9, 164, 88); + else if ((active6 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 445, 88); + else if ((active8 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(9, 528, 88); + return jjMoveStringLiteralDfa10_2(active0, 0x40010800000000L, active1, 0xf000000004L, active2, 0x100000000000000L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1fff0000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active4 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(9, 303, 88); + break; + case 89: + case 121: + if ((active4 & 0x400000L) != 0L) + { + jjmatchedKind = 278; + jjmatchedPos = 9; + } + else if ((active4 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(9, 283, 88); + else if ((active5 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 382, 88); + else if ((active8 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(9, 529, 88); + else if ((active9 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(9, 631, 88); + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa10_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000000000000000L, active11, 0L); + default : + break; + } + return jjStartNfa_2(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa10_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_2(8, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 10; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x7400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x6000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa11_2(active0, 0x800000L, active1, 0x8000000000000000L, active2, 0L, active3, 0x40000000000L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0xc84881fff0000400L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active8 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(10, 558, 88); + return jjMoveStringLiteralDfa11_2(active0, 0x1000000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0x10000L, active8, 0x1100000000000000L, active9, 0x4000000000L, active10, 0L); + case 68: + case 100: + if ((active3 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(10, 216, 88); + else if ((active5 & 0x80L) != 0L) + return jjStartNfaWithStates_2(10, 327, 88); + else if ((active5 & 0x100L) != 0L) + return jjStartNfaWithStates_2(10, 328, 88); + else if ((active9 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 638, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x100000000L, active10, 0L); + case 69: + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(10, 39, 88); + else if ((active1 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(10, 88, 88); + else if ((active2 & 0x4L) != 0L) + return jjStartNfaWithStates_2(10, 130, 88); + else if ((active3 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(10, 207, 88); + else if ((active4 & 0x10L) != 0L) + return jjStartNfaWithStates_2(10, 260, 88); + else if ((active7 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(10, 487, 88); + else if ((active7 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 506, 88); + else if ((active9 & 0x400000L) != 0L) + return jjStartNfaWithStates_2(10, 598, 88); + else if ((active9 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(10, 602, 88); + else if ((active10 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 701, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0x1000000000L, active7, 0x1000000000008000L, active8, 0x2000000000000000L, active9, 0L, active10, 0x800080000f000L); + case 70: + case 102: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active6 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 442, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_2(10, 66, 88); + else if ((active6 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(10, 403, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L); + case 73: + case 105: + return jjMoveStringLiteralDfa11_2(active0, 0x10800000000L, active1, 0x200000001000L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xa00000000L, active10, 0L); + case 76: + case 108: + if ((active1 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(10, 94, 88); + else if ((active8 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(10, 536, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x400000000000010L, active2, 0L, active3, 0L, active4, 0x80L, active5, 0L, active6, 0L, active7, 0x100020000000000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa11_2(active0, 0x1000000000000000L, active1, 0x6000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x80010000000L, active8, 0L, active9, 0x10000000000000L, active10, 0L); + case 78: + case 110: + if ((active2 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(10, 159, 88); + else if ((active8 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(10, 532, 88); + else if ((active9 & 0x10000000000L) != 0L) + { + jjmatchedKind = 616; + jjmatchedPos = 10; + } + else if ((active9 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 624, 88); + else if ((active10 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 696, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x86100000L, active2, 0xc00000000180L, active3, 0L, active4, 0L, active5, 0x8L, active6, 0x8000400L, active7, 0L, active8, 0x602000000000000L, active9, 0x80000e0000000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x2000L, active9, 0x400000000L, active10, 0L); + case 80: + case 112: + if ((active9 & 0x80L) != 0L) + return jjStartNfaWithStates_2(10, 583, 88); + else if ((active10 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 694, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active1 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(10, 104, 88); + else if ((active8 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(10, 539, 88); + else if ((active9 & 0x1L) != 0L) + return jjStartNfaWithStates_2(10, 576, 88); + else if ((active9 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(10, 599, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0x800000021000L, active10, 0L); + case 83: + case 115: + if ((active1 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_2(10, 103, 88); + else if ((active2 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(10, 162, 88); + else if ((active4 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(10, 280, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x2001e0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active4 & 0x2000000L) != 0L) + { + jjmatchedKind = 281; + jjmatchedPos = 10; + } + else if ((active8 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 564, 88); + else if ((active9 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(10, 589, 88); + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0x2c0000000000000L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0x10000004000000L, active5, 0x800000000010L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000000L, active9, 0L, active10, 0L); + case 87: + case 119: + if ((active1 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 123, 88); + break; + case 88: + case 120: + return jjMoveStringLiteralDfa11_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x20L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 54, 88); + else if ((active3 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 247, 88); + else if ((active8 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(10, 565, 88); + break; + default : + break; + } + return jjStartNfa_2(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa11_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(9, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 11; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active7 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(11, 491, 88); + return jjMoveStringLiteralDfa12_2(active0, 0x1000000L, active1, 0x140000000180000L, active2, 0L, active3, 0L, active4, 0x10000004000000L, active5, 0L, active6, 0x400L, active7, 0x8000000L, active8, 0L, active9, 0x8008000000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0x1006200000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x40040000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x100000000L) != 0L) + return jjStartNfaWithStates_2(11, 608, 88); + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 69: + case 101: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 60, 88); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 119, 88); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 122, 88); + else if ((active1 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 125; + jjmatchedPos = 11; + } + else if ((active4 & 0x80L) != 0L) + return jjStartNfaWithStates_2(11, 263, 88); + else if ((active7 & 0x10000000L) != 0L) + return jjStartNfaWithStates_2(11, 476, 88); + else if ((active7 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 504, 88); + else if ((active8 & 0x800L) != 0L) + return jjStartNfaWithStates_2(11, 523, 88); + else if ((active9 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 628, 88); + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0x50000000000000f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0x4000000000000000L, active7, 0x20000000L, active8, 0L, active9, 0x20800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0x8L, active6, 0x1000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 121, 88); + else if ((active5 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(11, 367, 88); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000L, active10, 0L); + case 75: + case 107: + if ((active6 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(11, 411, 88); + else if ((active8 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 573, 88); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0x1fff0000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000400L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(11, 76, 88); + else if ((active4 & 0x800L) != 0L) + return jjStartNfaWithStates_2(11, 267, 88); + else if ((active8 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(11, 525, 88); + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0x8000202400000000L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0x80000000000L, active9, 0x800000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa12_2(active0, 0x800000000L, active1, 0L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x20000000000L, active8, 0x1000000000000000L, active9, 0x4000000000L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active2 & 0x1L) != 0L) + return jjStartNfaWithStates_2(11, 128, 88); + else if ((active4 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 316, 88); + else if ((active7 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 508, 88); + else if ((active8 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(11, 559, 88); + else if ((active8 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 567, 88); + else if ((active8 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 574, 88); + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x8900000000000000L, active9, 0L, active10, 0x20000000000000L); + case 83: + case 115: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe0000000000L, active10, 0L); + case 84: + case 116: + if ((active3 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(11, 234, 88); + else if ((active5 & 0x20L) != 0L) + return jjStartNfaWithStates_2(11, 325, 88); + else if ((active8 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 561, 88); + else if ((active10 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(11, 675, 88); + return jjMoveStringLiteralDfa12_2(active0, 0x10000800000L, active1, 0x100L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x400000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa12_2(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x200000000000000L, active9, 0x400000000L, active10, 0L); + case 89: + case 121: + if ((active10 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(11, 691, 88); + break; + default : + break; + } + return jjStartNfa_2(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa12_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(10, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 12; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa13_2(active0, 0x800000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4001fff0000000L, active9, 0xe0000000000L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x3400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active2 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(12, 161, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0xa00L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x400L) != 0L) + return jjStartNfaWithStates_2(12, 522, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000007000L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + if ((active9 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(12, 609, 88); + break; + case 71: + case 103: + if ((active1 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_2(12, 109, 88); + else if ((active4 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(12, 279, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000000L, active5, 0L, active6, 0L, active7, 0x20000008000L, active8, 0L, active9, 0x800000021000L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_2(12, 570, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa13_2(active0, 0x10000000000L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 76: + case 108: + if ((active9 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(12, 639, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x1000000080100000L, active2, 0L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0x400L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(12, 35, 88); + else if ((active2 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(12, 184, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x100000000000000L, active9, 0L, active10, 0x20000000000000L); + case 80: + case 112: + if ((active8 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(12, 563, 88); + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active9 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(12, 610, 88); + return jjMoveStringLiteralDfa13_2(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0xc000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x60800e0L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0x18L, active6, 0L, active7, 0L, active8, 0xa00000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa13_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x4800000000L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(12, 575, 88); + break; + default : + break; + } + return jjStartNfa_2(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa13_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(11, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 13; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0xe0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 124, 88); + else if ((active7 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(13, 477, 88); + else if ((active9 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 629, 88); + return jjMoveStringLiteralDfa14_2(active0, 0x800000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0x20000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 572, 88); + return jjMoveStringLiteralDfa14_2(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xf0000000L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x100000L) != 0L) + return jjStartNfaWithStates_2(13, 84, 88); + else if ((active6 & 0x200L) != 0L) + return jjStartNfaWithStates_2(13, 393, 88); + else if ((active6 & 0x400L) != 0L) + return jjStartNfaWithStates_2(13, 394, 88); + else if ((active8 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 569, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0x800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active4 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(13, 282, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x8L) != 0L) + return jjStartNfaWithStates_2(13, 323, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80700000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x1000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x2400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active3 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 248, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x20000000000L, active9, 0x4000000000L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa14_2(active0, 0x10000000000L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 80: + case 112: + if ((active4 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 308, 88); + break; + case 82: + case 114: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 83: + case 115: + if ((active7 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(13, 489, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(13, 446, 88); + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x38000L, active8, 0L, active9, 0x800000000L, active10, 0xf000L); + case 88: + case 120: + if ((active6 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(13, 420, 88); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa14_2(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_2(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa14_2(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(12, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 14; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0xa00f0000000L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active6 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(14, 410, 88); + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x20L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(14, 98, 88); + else if ((active1 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(14, 101, 88); + else if ((active4 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_2(14, 317, 88); + else if ((active9 & 0x800000000L) != 0L) + return jjStartNfaWithStates_2(14, 611, 88); + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x4080000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x14001c000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(14, 118, 88); + else if ((active7 & 0x8000000L) != 0L) + return jjStartNfaWithStates_2(14, 475, 88); + else if ((active9 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_2(14, 627, 88); + return jjMoveStringLiteralDfa15_2(active0, 0x800000L, active1, 0L, active2, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active7 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(14, 463, 88); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa15_2(active0, 0x1000000L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x80000L, active2, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x200000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(14, 40, 88); + else if ((active9 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(14, 588, 88); + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x40L, active2, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x8000000006000000L, active2, 0xc00000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2700000000L, active9, 0xc0000000000L, active10, 0L); + case 82: + case 114: + if ((active8 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(14, 554, 88); + else if ((active8 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_2(14, 571, 88); + break; + case 83: + case 115: + if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_2(14, 72, 88); + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x80L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x2000000L) != 0L) + return jjStartNfaWithStates_2(14, 409, 88); + else if ((active9 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(14, 614, 88); + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0x100000000000010L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0L, active2, 0x180L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active9 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(14, 593, 88); + else if ((active9 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(14, 623, 88); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa15_2(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + default : + break; + } + return jjStartNfa_2(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa15_2(long old0, long active0, long old1, long active1, long old2, long active2, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(13, old0, old1, old2, 0L, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 15; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x200000L) != 0L) + return jjStartNfaWithStates_2(15, 85, 88); + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x60L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0x400000000010L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_2(15, 23, 88); + break; + case 72: + case 104: + if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_2(15, 68, 88); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x4000004000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 15; + } + else if ((active2 & 0x400000000000L) != 0L) + { + jjmatchedKind = 174; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_2(active0, 0x1000000L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x80000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 82: + case 114: + if ((active1 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(15, 95, 88); + else if ((active8 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(15, 555, 88); + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x700000000L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x10000000L) != 0L) + { + jjmatchedKind = 540; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa16_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + default : + break; + } + return jjStartNfa_2(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa16_2(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(14, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 16; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(16, 102, 88); + return jjMoveStringLiteralDfa17_2(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 69: + case 101: + if ((active7 & 0x20000L) != 0L) + return jjStartNfaWithStates_2(16, 465, 88); + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0xf000L); + case 71: + case 103: + if ((active1 & 0x80000L) != 0L) + return jjStartNfaWithStates_2(16, 83, 88); + break; + case 72: + case 104: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0x8000000000000040L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + if ((active1 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_2(16, 126, 88); + break; + case 82: + case 114: + if ((active8 & 0x100000000L) != 0L) + { + jjmatchedKind = 544; + jjmatchedPos = 16; + } + else if ((active8 & 0x8000000000L) != 0L) + { + jjmatchedKind = 551; + jjmatchedPos = 16; + } + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0x100000000000020L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa17_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active5 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_2(16, 366, 88); + break; + case 89: + case 121: + if ((active8 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(16, 553, 88); + break; + default : + break; + } + return jjStartNfa_2(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa17_2(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(15, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0x8000000000000000L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_2(17, 70, 88); + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(17, 100, 88); + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_2(17, 549, 88); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa18_2(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 82: + case 114: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18e0000000L, active9, 0L, active10, 0x20000000000000L); + case 86: + case 118: + return jjMoveStringLiteralDfa18_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_2(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa18_2(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(16, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 18; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0x80L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x3000L); + case 68: + case 100: + if ((active8 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_2(18, 550, 88); + else if ((active8 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_2(18, 566, 88); + else if ((active8 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(18, 568, 88); + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x800000000L) != 0L) + { + jjmatchedKind = 547; + jjmatchedPos = 18; + } + else if ((active9 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_2(18, 617, 88); + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa19_2(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4000L); + case 79: + case 111: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0x100L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 84: + case 116: + return jjMoveStringLiteralDfa19_2(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0x4000L, active8, 0x10600000000L, active9, 0x40000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_2(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa19_2(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(17, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 19; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10e0000000L, active9, 0x80000000000L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_2(19, 71, 88); + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x5000L); + case 67: + case 99: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x1000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 68: + case 100: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x10L) != 0L) + return jjStartNfaWithStates_2(19, 324, 88); + break; + case 78: + case 110: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0x2000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0x20L, active2, 0x80L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0x20000000002000L); + case 82: + case 114: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0x8000000000000000L, active2, 0x100L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa20_2(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa20_2(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 89: + case 121: + if ((active7 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(19, 462, 88); + break; + default : + break; + } + return jjStartNfa_2(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa20_2(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(18, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); + return 20; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0x3000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0x80L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000L); + case 69: + case 101: + if ((active1 & 0x4000000L) != 0L) + return jjStartNfaWithStates_2(20, 90, 88); + else if ((active2 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_2(20, 175, 88); + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0x100L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_2(20, 69, 88); + break; + case 72: + case 104: + if ((active7 & 0x10000L) != 0L) + return jjStartNfaWithStates_2(20, 464, 88); + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x20000000L, active9, 0L, active10, 0x8000L); + case 77: + case 109: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x40000000L, active9, 0L, active10, 0x4000L); + case 78: + case 110: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0x100000000000000L, active2, 0L, active6, 0x800L, active7, 0L, active8, 0x80000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa21_2(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0x1000L); + case 89: + case 121: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_2(20, 24, 88); + break; + default : + break; + } + return jjStartNfa_2(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa21_2(long old0, long active0, long old1, long active1, long old2, long active2, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(19, old0, old1, old2, 0L, 0L, 0L, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 21; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 65: + case 97: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0x80000000000L, active10, 0x1000L); + case 67: + case 99: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_2(21, 618, 88); + break; + case 69: + case 101: + if ((active2 & 0x80L) != 0L) + return jjStartNfaWithStates_2(21, 135, 88); + else if ((active10 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(21, 653, 88); + else if ((active10 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(21, 654, 88); + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x8000L); + case 70: + case 102: + return jjMoveStringLiteralDfa22_2(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0x800L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0x2000L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x1020000000L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa22_2(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa22_2(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_2(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa22_2(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(20, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 22; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active6 & 0x2000L) != 0L) + return jjStartNfaWithStates_2(22, 397, 88); + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x200000000L, active9, 0L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x1000L); + case 77: + case 109: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000008000L); + case 78: + case 110: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa23_2(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0x10000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa23_2(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa23_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x20000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_2(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa23_2(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(21, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 23; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa24_2(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active10 & 0x8000L) != 0L) + return jjStartNfaWithStates_2(23, 655, 88); + break; + case 67: + case 99: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 75: + case 107: + if ((active9 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_2(23, 619, 88); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x20000000001000L); + case 82: + case 114: + if ((active8 & 0x20000000L) != 0L) + return jjStartNfaWithStates_2(23, 541, 88); + return jjMoveStringLiteralDfa24_2(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa24_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_2(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa24_2(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_2(22, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 24; + } + switch(curChar) + { + case 65: + case 97: + if ((active6 & 0x4000L) != 0L) + return jjStartNfaWithStates_2(24, 398, 88); + break; + case 68: + case 100: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active10, 0x20000000000000L); + case 69: + case 101: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa25_2(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 71: + case 103: + if ((active10 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(24, 652, 88); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa25_2(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0x1800L, active8, 0x400000000L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x10040000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa25_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_2(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa25_2(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_2(23, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 25; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa26_2(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa26_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x80000000L) != 0L) + return jjStartNfaWithStates_2(25, 543, 88); + break; + case 69: + case 101: + if ((active8 & 0x40000000L) != 0L) + return jjStartNfaWithStates_2(25, 542, 88); + else if ((active10 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_2(25, 693, 88); + break; + case 71: + case 103: + if ((active6 & 0x1000L) != 0L) + return jjStartNfaWithStates_2(25, 396, 88); + break; + case 72: + case 104: + if ((active8 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_2(25, 552, 88); + break; + case 78: + case 110: + if ((active6 & 0x800L) != 0L) + return jjStartNfaWithStates_2(25, 395, 88); + return jjMoveStringLiteralDfa26_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa26_2(active1, 0x8000000000000000L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa26_2(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_2(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa26_2(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_2(24, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 26; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x400000000L) != 0L) + return jjStartNfaWithStates_2(26, 546, 88); + break; + case 69: + case 101: + if ((active8 & 0x200000000L) != 0L) + return jjStartNfaWithStates_2(26, 545, 88); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa27_2(active1, 0x100000000000000L, active2, 0L, active8, 0L); + case 78: + case 110: + if ((active2 & 0x100L) != 0L) + return jjStartNfaWithStates_2(26, 136, 88); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa27_2(active1, 0L, active2, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa27_2(active1, 0x8000000000000000L, active2, 0L, active8, 0L); + default : + break; + } + return jjStartNfa_2(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa27_2(long old1, long active1, long old2, long active2, long old8, long active8) +{ + if (((active1 &= old1) | (active2 &= old2) | (active8 &= old8)) == 0L) + return jjStartNfa_2(25, 0L, old1, old2, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 27; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa28_2(active1, 0x8000000000000000L, active8, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa28_2(active1, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa28_2(active1, 0x100000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_2(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa28_2(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_2(26, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 28; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_2(28, 548, 88); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa29_2(active1, 0x100000000000000L, active8, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa29_2(active1, 0x8000000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_2(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa29_2(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_2(27, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 29; + } + switch(curChar) + { + case 85: + case 117: + return jjMoveStringLiteralDfa30_2(active1, 0x100000000000000L); + case 89: + case 121: + return jjMoveStringLiteralDfa30_2(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_2(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa30_2(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_2(28, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 30; + } + switch(curChar) + { + case 80: + case 112: + if ((active1 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_2(30, 120, 88); + return jjMoveStringLiteralDfa31_2(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_2(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa31_2(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_2(29, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_2(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 31; + } + switch(curChar) + { + case 69: + case 101: + if ((active1 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_2(31, 127, 88); + break; + default : + break; + } + return jjStartNfa_2(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveNfa_2(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 86; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 88: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 86: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(3, 5); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 84: + if (curChar == 47) + { + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + } + else if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 82; + break; + case 58: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 59; + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 55: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + else if (curChar == 39) + { + if (kind > 720) + kind = 720; + } + if ((0xfc00f7faffffc9ffL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 87: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 90: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if (curChar == 36) + jjCheckNAdd(31); + break; + case 89: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 1: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + else if (curChar == 39) + jjCheckNAddStates(15, 17); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (curChar == 36) + jjCheckNAdd(31); + break; + case 0: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 47) + jjAddStates(18, 19); + else if (curChar == 39) + jjCheckNAddStates(20, 23); + else if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + else if (curChar == 7) + { + if (kind > 786) + kind = 786; + } + else if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + } + else if (curChar == 36) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 2: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(15, 17); + break; + case 3: + if (curChar == 39) + jjCheckNAddStates(15, 17); + break; + case 4: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 3; + break; + case 5: + if (curChar == 39 && kind > 719) + kind = 719; + break; + case 7: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7ff600000000000L & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 9: + case 11: + if (curChar == 39) + jjCheckNAddStates(3, 5); + break; + case 10: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 12: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 11; + break; + case 13: + if (curChar == 39 && kind > 721) + kind = 721; + break; + case 15: + if (curChar != 45) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 16: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + case 17: + if ((0x2400L & l) != 0L && kind > 772) + kind = 772; + break; + case 18: + if (curChar == 10 && kind > 772) + kind = 772; + break; + case 19: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 18; + break; + case 20: + if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 15; + break; + case 22: + if ((0xffffffffffffdbffL & l) != 0L) + jjAddStates(6, 8); + break; + case 26: + if (curChar != 36) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 29: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 30: + if (curChar == 36) + jjCheckNAdd(31); + break; + case 31: + if (curChar != 36) + break; + if (kind > 782) + kind = 782; + jjCheckNAddTwoStates(31, 32); + break; + case 32: + if (curChar == 36) + jjCheckNAdd(33); + break; + case 33: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjCheckNAdd(33); + break; + case 34: + if (curChar == 7 && kind > 786) + kind = 786; + break; + case 35: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAddStates(24, 30); + break; + case 36: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAdd(36); + break; + case 37: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(37, 38); + break; + case 39: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(40); + break; + case 40: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 714) + kind = 714; + jjCheckNAdd(40); + break; + case 41: + if (curChar == 46) + jjCheckNAddTwoStates(42, 38); + break; + case 42: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(42, 38); + break; + case 43: + if (curChar != 46) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 44: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(44); + break; + case 45: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAddStates(31, 33); + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(34, 37); + break; + case 47: + if (curChar == 46) + jjCheckNAddTwoStates(48, 49); + break; + case 48: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(48, 38); + break; + case 49: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(49); + break; + case 50: + if (curChar == 39) + jjCheckNAddStates(20, 23); + break; + case 51: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 52: + if (curChar == 39) + jjCheckNAddStates(12, 14); + break; + case 53: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 54: + if (curChar == 39 && kind > 720) + kind = 720; + break; + case 56: + if (curChar == 39 && kind > 726) + kind = 726; + break; + case 59: + case 61: + if (curChar == 39) + jjCheckNAddStates(38, 40); + break; + case 60: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(38, 40); + break; + case 62: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 61; + break; + case 63: + if (curChar == 39 && kind > 722) + kind = 722; + break; + case 64: + if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 65; + break; + case 65: + if (curChar == 34) + jjCheckNAddTwoStates(66, 68); + break; + case 66: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(41, 43); + break; + case 67: + if (curChar == 34) + jjCheckNAddStates(41, 43); + break; + case 68: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 67; + break; + case 69: + if (curChar == 34 && kind > 783) + kind = 783; + break; + case 71: + if (curChar == 32) + jjCheckNAddTwoStates(71, 72); + break; + case 73: + if (curChar == 32) + jjCheckNAddTwoStates(73, 74); + break; + case 75: + if (curChar == 32) + jjCheckNAddTwoStates(75, 76); + break; + case 78: + if (curChar == 32) + jjCheckNAddTwoStates(78, 79); + break; + case 81: + if (curChar == 47) + jjAddStates(18, 19); + break; + case 82: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 83; + break; + case 83: + if ((0xffff7fffffffffffL & l) != 0L && kind > 770) + kind = 770; + break; + case 85: + if (curChar != 47) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(9, 11); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 88: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 86: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 58: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 55: + jjCheckNAddStates(12, 14); + if ((0xffffff81ffffff81L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 87: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + else if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + else if ((0x1000000010L & l) != 0L) + { + if (kind > 729) + kind = 729; + } + if ((0x10000000100000L & l) != 0L) + { + if (kind > 730) + kind = 730; + } + break; + case 90: + case 29: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(29, 30); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + else if (curChar == 123) + jjAddStates(44, 51); + else if (curChar == 96) + jjCheckNAddTwoStates(22, 24); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + else if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + else if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 1; + else if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 2: + jjAddStates(15, 17); + break; + case 6: + if (curChar == 95) + jjstateSet[jjnewStateCnt++] = 7; + break; + case 7: + if ((0x7fffffe07fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 8: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(8, 9); + break; + case 10: + jjAddStates(3, 5); + break; + case 14: + if ((0x400000004000L & l) != 0L) + jjCheckNAdd(9); + break; + case 16: + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 21: + if (curChar == 96) + jjCheckNAddTwoStates(22, 24); + break; + case 22: + if ((0xfffffffeffffffffL & l) != 0L) + jjCheckNAddStates(6, 8); + break; + case 23: + if (curChar == 96) + jjCheckNAddStates(6, 8); + break; + case 24: + if (curChar == 96) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 25: + if (curChar == 96 && kind > 778) + kind = 778; + break; + case 26: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 31: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 38: + if ((0x2000000020L & l) != 0L) + jjAddStates(56, 57); + break; + case 51: + jjCheckNAddStates(12, 14); + break; + case 57: + if ((0x20000000200000L & l) != 0L) + jjAddStates(52, 53); + break; + case 60: + jjAddStates(38, 40); + break; + case 66: + jjAddStates(41, 43); + break; + case 70: + if (curChar == 123) + jjAddStates(44, 51); + break; + case 72: + if ((0x1000000010L & l) != 0L && kind > 729) + kind = 729; + break; + case 74: + if ((0x10000000100000L & l) != 0L && kind > 730) + kind = 730; + break; + case 76: + if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 77; + break; + case 77: + if ((0x8000000080000L & l) != 0L && kind > 731) + kind = 731; + break; + case 79: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 80; + break; + case 80: + if ((0x400000004000L & l) != 0L && kind > 732) + kind = 732; + break; + case 83: + if (kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 88: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 86: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 58: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 55: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 90: + case 29: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 1: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(29, 30); + break; + case 0: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 2: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(15, 17); + break; + case 10: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(3, 5); + break; + case 16: + if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) + break; + if (kind > 772) + kind = 772; + jjAddStates(9, 11); + break; + case 22: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(6, 8); + break; + case 26: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 27: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(27); + break; + case 28: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(0, 2); + break; + case 31: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjAddStates(54, 55); + break; + case 33: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 33; + break; + case 51: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(12, 14); + break; + case 60: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(38, 40); + break; + case 66: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(41, 43); + break; + case 83: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 86 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + switch (pos) + { + case 0: + if ((active10 & 0x80000000000L) != 0L) + { + jjmatchedKind = 781; + return 1; + } + if ((active11 & 0x10000400000000L) != 0L) + return 76; + if ((active11 & 0x20000000000000L) != 0L) + return 58; + if ((active11 & 0x20000000L) != 0L) + return 77; + if ((active11 & 0x1000000000000L) != 0L || (active12 & 0x9L) != 0L) + return 74; + if ((active0 & 0x7ffe000000000L) != 0L || (active2 & 0xfffffffffffffff0L) != 0L || (active3 & 0xffffe0007fffffffL) != 0L || (active4 & 0x7ffffe1fffffffL) != 0L || (active5 & 0xffffffffffc00000L) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0x7fffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xfffffffffffffffL) != 0L || (active10 & 0xff27f7fffff00000L) != 0L || (active11 & 0x95L) != 0L) + { + jjmatchedKind = 781; + return 78; + } + if ((active0 & 0xfff8001ffffffff8L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfL) != 0L || (active3 & 0x1fff80000000L) != 0L || (active4 & 0xff800001e0000000L) != 0L || (active5 & 0x3fffffL) != 0L || (active7 & 0x8000000000000000L) != 0L || (active10 & 0xd8000000000000L) != 0L || (active11 & 0x20000000000006aL) != 0L) + return 78; + if ((active11 & 0x400000000000L) != 0L) + return 11; + if ((active11 & 0x40000000000000L) != 0L) + return 79; + if ((active9 & 0xf000000000000000L) != 0L || (active10 & 0xfffffL) != 0L || (active11 & 0x100L) != 0L) + { + jjmatchedKind = 781; + return 31; + } + return -1; + case 1: + if ((active0 & 0xfff3fff801fffff0L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xffffffffffffffffL) != 0L || (active3 & 0x3ffff9f7fffffffL) != 0L || (active4 & 0xff7dffffdff80000L) != 0L || (active5 & 0x8719ffe0ffffffffL) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0xffffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xffffff9fffffffffL) != 0L || (active10 & 0x57eeffffffffffffL) != 0L || (active11 & 0x1bfL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 781; + jjmatchedPos = 1; + } + return 78; + } + if ((active12 & 0x9L) != 0L) + return 72; + if ((active0 & 0x40007fe000000L) != 0L || (active3 & 0xfc00006000000000L) != 0L || (active4 & 0x200000007ffffL) != 0L || (active5 & 0x78e6001f00000000L) != 0L || (active9 & 0x6000000000L) != 0L || (active10 & 0xa811000000000000L) != 0L || (active11 & 0x40L) != 0L) + return 78; + return -1; + case 2: + if ((active0 & 0xfff3dfef79e98c80L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfe1ff2ffffff09ffL) != 0L || (active3 & 0xfbfeffd77f87ff9fL) != 0L || (active4 & 0x3e7dfffa1fff40ffL) != 0L || (active5 & 0xf795ffeebffe03ffL) != 0L || (active6 & 0xf8fffffdc07fff78L) != 0L || (active7 & 0x1ffffffc3fffffffL) != 0L || (active8 & 0xfffL) != 0L || (active9 & 0xffffffdffff7fffeL) != 0L || (active10 & 0xfffef7ffffffffffL) != 0L || (active11 & 0x1ffL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 781; + jjmatchedPos = 2; + } + return 78; + } + if ((active0 & 0x201004167370L) != 0L || (active2 & 0x1e00d000000f600L) != 0L || (active3 & 0x1000800780060L) != 0L || (active4 & 0xc1000005c0003f00L) != 0L || (active5 & 0x4800104001fc00L) != 0L || (active6 & 0x70000023f800087L) != 0L || (active7 & 0xe0000003c0000000L) != 0L || (active8 & 0xfffffffffffff000L) != 0L || (active9 & 0x80001L) != 0L || (active10 & 0x80000000000L) != 0L) + return 78; + return -1; + case 3: + if ((active0 & 0x99c29fef79e9ece0L) != 0L || (active1 & 0xfff7cfffffffdc01L) != 0L || (active2 & 0xff9ae2fe1fffe80fL) != 0L || (active3 & 0xfbf87f9763f7ffd3L) != 0L || (active4 & 0xbe7d389b80075effL) != 0L || (active5 & 0xf605f86c3f37bbffL) != 0L || (active6 & 0xfe87f7fcff4fff06L) != 0L || (active7 & 0x9febfffdbf7fffffL) != 0L || (active8 & 0xffffffffffffefa6L) != 0L || (active9 & 0xf63fffd00ff7fffdL) != 0L || (active10 & 0xfefe061c3ffd07ffL) != 0L || (active11 & 0xf9L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 781; + jjmatchedPos = 3; + } + return 78; + } + if ((active2 & 0x40000000000000L) != 0L) + return 80; + if ((active0 & 0x6631400000000000L) != 0L || (active1 & 0x83000000023feL) != 0L || (active2 & 0x51001e00005f0L) != 0L || (active3 & 0x680401c00000cL) != 0L || (active4 & 0xc7601ff82000L) != 0L || (active5 & 0x190078280c80000L) != 0L || (active6 & 0x78080100300078L) != 0L || (active7 & 0x4014000200800000L) != 0L || (active8 & 0x59L) != 0L || (active9 & 0x9c0000ff0000002L) != 0L || (active10 & 0x100f1e3c002f800L) != 0L || (active11 & 0x106L) != 0L) + return 78; + return -1; + case 4: + if ((active2 & 0x40000000000000L) != 0L) + return 80; + if ((active0 & 0x1c001e8cc00L) != 0L || (active1 & 0x4400000014401L) != 0L || (active2 & 0x2a0800000c000008L) != 0L || (active3 & 0x241f800083ec00L) != 0L || (active4 & 0x3e5d10120000000eL) != 0L || (active5 & 0x3000044018a60004L) != 0L || (active6 & 0x24202040000002L) != 0L || (active7 & 0x80000f2000600100L) != 0L || (active8 & 0x100L) != 0L || (active9 & 0x200000700081cL) != 0L || (active10 & 0xa202404007d0503L) != 0L || (active11 & 0xc0L) != 0L) + return 78; + if ((active0 & 0xd9e29e2f780120e0L) != 0L || (active1 & 0xfff3affffffe9bfcL) != 0L || (active2 & 0xd592e2ffd3ffe9a7L) != 0L || (active3 & 0xfbd86017637413dbL) != 0L || (active4 & 0x8020aac99fc75ef1L) != 0L || (active5 & 0xc605fb2c2711bbfbL) != 0L || (active6 & 0xfe83d7dcbf4fff74L) != 0L || (active7 & 0x1febf0ddbf1ffeffL) != 0L || (active8 & 0xffffffffffffeea6L) != 0L || (active9 & 0xf6bdffdf88f7f7e1L) != 0L || (active10 & 0xf5de02da3f80f2fcL) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 781; + jjmatchedPos = 4; + } + return 78; + } + return -1; + case 5: + if ((active0 & 0xd9c2878e79c02040L) != 0L || (active1 & 0xfff1afffe67e9bfcL) != 0L || (active2 & 0x192e07fd20fc9a1L) != 0L || (active3 & 0xf9c84d072364834bL) != 0L || (active4 & 0xbc38a2c99fc65ed1L) != 0L || (active5 & 0x6000d12c2710a3b9L) != 0L || (active6 & 0xfe82d7dcaf4dff70L) != 0L || (active7 & 0x19e30e0dbd000effL) != 0L || (active8 & 0xffffffffffffee22L) != 0L || (active9 & 0xf2bdffdf8e17b6d1L) != 0L || (active10 & 0xf7ee028a3fc0f038L) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 781; + jjmatchedPos = 5; + } + return 78; + } + if ((active2 & 0x40000000000000L) != 0L) + return 80; + if ((active0 & 0x201821000100a0L) != 0L || (active1 & 0x2000019800000L) != 0L || (active2 & 0xd400028001f02006L) != 0L || (active3 & 0x210301040101090L) != 0L || (active4 & 0x80000010020L) != 0L || (active5 & 0x86052a0000051842L) != 0L || (active6 & 0x1000010020004L) != 0L || (active7 & 0x608f0d0021ff000L) != 0L || (active8 & 0x84L) != 0L || (active9 & 0x400000000e04120L) != 0L || (active10 & 0x100050002002c4L) != 0L) + return 78; + return -1; + case 6: + if ((active0 & 0x40038e79c02040L) != 0L || (active1 & 0x11a7f8f73c9bfcL) != 0L || (active2 & 0x8190007fc20c09a4L) != 0L || (active3 & 0x71c84c0623048102L) != 0L || (active4 & 0xb01880499fc41cd0L) != 0L || (active5 & 0x6000c12c0310a3b9L) != 0L || (active6 & 0x7e80c5d800097f50L) != 0L || (active7 & 0x5e20e898107c85fL) != 0L || (active8 & 0xfffffffffffbee20L) != 0L || (active9 & 0xe281ffcf8ed7b6d1L) != 0L || (active10 & 0xb7fa000a0340f000L) != 0L || (active11 & 0x9L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 781; + jjmatchedPos = 6; + } + return 78; + } + if ((active2 & 0x40000000000000L) != 0L) + return 80; + if ((active0 & 0xd982840000000000L) != 0L || (active1 & 0xffe0080700420000L) != 0L || (active2 & 0x2e0001063c001L) != 0L || (active3 & 0x8800010100600249L) != 0L || (active4 & 0xc20228000024201L) != 0L || (active5 & 0x400100024001000L) != 0L || (active6 & 0x80021204af448020L) != 0L || (active7 & 0x180180043c0806a0L) != 0L || (active8 & 0x40002L) != 0L || (active9 & 0x103c001000000000L) != 0L || (active10 & 0x400402803c800038L) != 0L || (active11 & 0x30L) != 0L) + return 78; + return -1; + case 7: + if ((active0 & 0x1040038e79c00000L) != 0L || (active1 & 0xffd1a1fef73c1bfcL) != 0L || (active2 & 0x8180c01782040985L) != 0L || (active3 & 0x71c0440203048002L) != 0L || (active4 & 0x301880409fc40c91L) != 0L || (active5 & 0x4000c02c010003b8L) != 0L || (active6 & 0x7e80c1800e097f40L) != 0L || (active7 & 0x15600e89b807c041L) != 0L || (active8 & 0xfff2ffffff13a000L) != 0L || (active9 & 0xe0b9ff4f8ed3b6d1L) != 0L || (active10 & 0xa7f800082200f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 7) + { + jjmatchedKind = 781; + jjmatchedPos = 7; + } + return 78; + } + if ((active2 & 0x40000000000000L) != 0L) + return 80; + if ((active0 & 0x100000000002040L) != 0L || (active1 & 0x60000008000L) != 0L || (active2 & 0x100068400a0020L) != 0L || (active3 & 0x8080420000100L) != 0L || (active4 & 0x8000000900001040L) != 0L || (active5 & 0x200001000210a001L) != 0L || (active6 & 0x45800000010L) != 0L || (active7 & 0x8200000100081eL) != 0L || (active8 & 0xd000000e84e20L) != 0L || (active9 & 0x200008000040000L) != 0L || (active10 & 0x1002000201400000L) != 0L || (active11 & 0x1L) != 0L) + return 78; + return -1; + case 8: + if ((active0 & 0x1040018869800000L) != 0L || (active1 & 0xffc121fe07001804L) != 0L || (active2 & 0x100c01782040985L) != 0L || (active3 & 0x100040001008000L) != 0L || (active4 & 0x300080409fc00090L) != 0L || (active5 & 0x4000c000010003b8L) != 0L || (active6 & 0x660040100e080040L) != 0L || (active7 & 0x15000e813803c041L) != 0L || (active8 & 0xfffacffffb13ac00L) != 0L || (active9 & 0xc0b90f4c06c0b2c1L) != 0L || (active10 & 0x23e800082000f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 8) + { + jjmatchedKind = 781; + jjmatchedPos = 8; + } + return 78; + } + if ((active0 & 0x20610400000L) != 0L || (active1 & 0x108000f03c03f8L) != 0L || (active2 & 0x8080000000000000L) != 0L || (active3 & 0x70c0400202040002L) != 0L || (active4 & 0x18000000040c01L) != 0L || (active5 & 0x2c00000000L) != 0L || (active6 & 0x1880818000017f00L) != 0L || (active7 & 0x60000880040000L) != 0L || (active8 & 0x300004000000L) != 0L || (active9 & 0x2000f00388130410L) != 0L || (active10 & 0x8410000002000000L) != 0L) + return 78; + return -1; + case 9: + if ((active0 & 0x1040018801800000L) != 0L || (active1 & 0xffc02100c73811f4L) != 0L || (active2 & 0x100c00680000185L) != 0L || (active3 & 0x180040001008000L) != 0L || (active4 & 0x3010000007000890L) != 0L || (active5 & 0xc000000001b8L) != 0L || (active6 & 0x440000100e087e00L) != 0L || (active7 & 0x15000a803803c000L) != 0L || (active8 & 0xfffacffff9102c00L) != 0L || (active9 & 0xc0398f4f04c23081L) != 0L || (active10 & 0x216800080000f000L) != 0L) + { + if (jjmatchedPos != 9) + { + jjmatchedKind = 781; + jjmatchedPos = 9; + } + return 78; + } + if ((active0 & 0x468000000L) != 0L || (active1 & 0x100fe00000a00L) != 0L || (active2 & 0x1102040800L) != 0L || (active4 & 0x804098c00000L) != 0L || (active5 & 0x4000000801000200L) != 0L || (active6 & 0x2200400000000040L) != 0L || (active7 & 0x40100000041L) != 0L || (active8 & 0x2038000L) != 0L || (active9 & 0x80200002008240L) != 0L || (active10 & 0x280000020000000L) != 0L || (active11 & 0x8L) != 0L) + return 78; + return -1; + case 10: + if ((active0 & 0x1000010801800000L) != 0L || (active1 & 0xf7c02074863811f0L) != 0L || (active2 & 0x100c00200000181L) != 0L || (active3 & 0x100040000000000L) != 0L || (active4 & 0x3010000000800880L) != 0L || (active5 & 0xc00000000038L) != 0L || (active6 & 0x400000100e007e00L) != 0L || (active7 & 0x11000a003803c000L) != 0L || (active8 & 0xffca8ffff0002c00L) != 0L || (active9 & 0x8038804f00021000L) != 0L || (active10 & 0x2800080000f000L) != 0L) + { + if (jjmatchedPos != 10) + { + jjmatchedKind = 781; + jjmatchedPos = 10; + } + return 78; + } + if ((active0 & 0x40008000000000L) != 0L || (active1 & 0x800018041000004L) != 0L || (active2 & 0x480000004L) != 0L || (active3 & 0x80000001008000L) != 0L || (active4 & 0x7000010L) != 0L || (active5 & 0x180L) != 0L || (active6 & 0x400000000080000L) != 0L || (active7 & 0x400008000000000L) != 0L || (active8 & 0x30400009100000L) != 0L || (active9 & 0x40010f0004c02081L) != 0L || (active10 & 0x2140000000000000L) != 0L) + return 78; + return -1; + case 11: + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x6680000000001000L) != 0L || (active2 & 0x1L) != 0L || (active3 & 0x40000000000L) != 0L || (active4 & 0x1000000000000880L) != 0L || (active5 & 0x800000000020L) != 0L || (active6 & 0x8000000L) != 0L || (active7 & 0x1100080010000000L) != 0L || (active8 & 0x6082800000002800L) != 0L || (active9 & 0x10000100000000L) != 0L || (active10 & 0x8000800000000L) != 0L) + return 78; + if ((active0 & 0x10801800000L) != 0L || (active1 & 0x91402074863801f0L) != 0L || (active2 & 0x100c00200000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004800000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x9f480ffff0000400L) != 0L || (active9 & 0x80288e4e00021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 11) + { + jjmatchedKind = 781; + jjmatchedPos = 11; + } + return 78; + } + return -1; + case 12: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xd1400074863801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004000000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x1b400ffff0000000L) != 0L || (active9 & 0x288e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 12; + return 78; + } + if ((active0 & 0x800000000L) != 0L || (active1 & 0x200000000000L) != 0L || (active2 & 0x100000200000000L) != 0L || (active4 & 0x800000L) != 0L || (active8 & 0x8408000000000400L) != 0L || (active9 & 0x8000000600000000L) != 0L) + return 78; + return -1; + case 13: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xc1400074862801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x6007800L) != 0L || (active7 & 0x803c000L) != 0L || (active8 & 0x9400ffff0000000L) != 0L || (active9 & 0x88e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 13; + return 78; + } + if ((active1 & 0x1000000000100000L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x10000004000000L) != 0L || (active5 & 0x8L) != 0L || (active6 & 0x4000001000000600L) != 0L || (active7 & 0x20020000000L) != 0L || (active8 & 0x1200000000000000L) != 0L || (active9 & 0x20000000000000L) != 0L) + return 78; + return -1; + case 14: + if ((active0 & 0x1800000L) != 0L || (active1 & 0xc1000050862800f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x1400bfff0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 14; + return 78; + } + if ((active0 & 0x10000000000L) != 0L || (active1 & 0x40002400000100L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active6 & 0x6000000L) != 0L || (active7 & 0x8008000L) != 0L || (active8 & 0x800040000000000L) != 0L || (active9 & 0x8804800021000L) != 0L) + return 78; + return -1; + case 15: + if ((active0 & 0x800000L) != 0L || (active1 & 0x86200010L) != 0L || (active2 & 0xc00000000000L) != 0L || (active8 & 0x800f0000000L) != 0L) + return 78; + if ((active0 & 0x1000000L) != 0L || (active1 & 0xc1000050000800e0L) != 0L || (active2 & 0x180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x14003ff00000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 15) + { + jjmatchedKind = 781; + jjmatchedPos = 15; + } + return 78; + } + return -1; + case 16: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000010040000e0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x1400078e0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 16) + { + jjmatchedKind = 781; + jjmatchedPos = 16; + } + return 78; + } + if ((active1 & 0x4000004000080000L) != 0L || (active5 & 0x400000000000L) != 0L || (active7 & 0x20000L) != 0L || (active8 & 0x38700000000L) != 0L) + return 78; + return -1; + case 17: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x140015ee0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 17; + return 78; + } + if ((active1 & 0x1000000040L) != 0L || (active8 & 0x2000000000L) != 0L) + return 78; + return -1; + case 18: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x106e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 18) + { + jjmatchedKind = 781; + jjmatchedPos = 18; + } + return 78; + } + if ((active8 & 0x140005800000000L) != 0L || (active9 & 0x20000000000L) != 0L) + return 78; + return -1; + case 19: + if ((active1 & 0x80L) != 0L || (active5 & 0x10L) != 0L || (active7 & 0x4000L) != 0L) + return 78; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x8100000004000020L) != 0L || (active2 & 0x800000000180L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x10000L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 19; + return 78; + } + return -1; + case 20: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x180L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 20; + return 78; + } + if ((active0 & 0x1000000L) != 0L || (active1 & 0x4000020L) != 0L || (active2 & 0x800000000000L) != 0L || (active7 & 0x10000L) != 0L) + return 78; + return -1; + case 21: + if ((active2 & 0x80L) != 0L || (active9 & 0x40000000000L) != 0L || (active10 & 0x6000L) != 0L) + return 78; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 21; + return 78; + } + return -1; + case 22: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 22; + return 78; + } + if ((active6 & 0x2000L) != 0L) + return 78; + return -1; + case 23: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000001000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 23; + return 78; + } + if ((active8 & 0x20000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x8000L) != 0L) + return 78; + return -1; + case 24: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x1800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 24; + return 78; + } + if ((active6 & 0x4000L) != 0L || (active10 & 0x1000L) != 0L) + return 78; + return -1; + case 25: + if ((active6 & 0x1800L) != 0L || (active8 & 0x100c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + return 78; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active8 & 0x1600000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 25; + return 78; + } + return -1; + case 26: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 26; + return 78; + } + if ((active2 & 0x100L) != 0L || (active8 & 0x600000000L) != 0L) + return 78; + return -1; + case 27: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 27; + return 78; + } + return -1; + case 28: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 28; + return 78; + } + if ((active8 & 0x1000000000L) != 0L) + return 78; + return -1; + case 29: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 29; + return 78; + } + return -1; + case 30: + if ((active1 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 781; + jjmatchedPos = 30; + return 78; + } + if ((active1 & 0x100000000000000L) != 0L) + return 78; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_3(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12), pos + 1); +} +private final int jjStartNfaWithStates_3(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_3(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_3() +{ + switch(curChar) + { + case 33: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000L, 0x0L); + case 34: + return jjStartNfaWithStates_3(0, 758, 79); + case 36: + return jjStartNfaWithStates_3(0, 761, 78); + case 37: + return jjStopAtPos(0, 753); + case 39: + return jjStartNfaWithStates_3(0, 757, 58); + case 40: + return jjStopAtPos(0, 727); + case 41: + return jjStopAtPos(0, 728); + case 42: + jjmatchedKind = 751; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L); + case 43: + return jjStopAtPos(0, 749); + case 44: + return jjStopAtPos(0, 739); + case 45: + return jjStartNfaWithStates_3(0, 750, 11); + case 46: + jjmatchedKind = 738; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x10000000000000L, 0x0L); + case 47: + jjmatchedKind = 752; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x9L); + case 58: + jjmatchedKind = 744; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L); + case 59: + return jjStopAtPos(0, 737); + case 60: + jjmatchedKind = 742; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xa0000000000L, 0x0L); + case 61: + jjmatchedKind = 740; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000L, 0x0L); + case 62: + jjmatchedKind = 741; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x40000000000L, 0x0L); + case 63: + return jjStopAtPos(0, 743); + case 91: + return jjStopAtPos(0, 735); + case 93: + return jjStopAtPos(0, 736); + case 94: + return jjStopAtPos(0, 760); + case 65: + case 97: + jjmatchedKind = 3; + return jjMoveStringLiteralDfa1_3(0x1ffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x18000000000000L, 0x40L, 0x0L); + case 66: + case 98: + return jjMoveStringLiteralDfa1_3(0x7ffe000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L, 0x0L); + case 67: + case 99: + jjmatchedKind = 51; + return jjMoveStringLiteralDfa1_3(0xfff0000000000000L, 0xffffffffffffffffL, 0xfL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xc0000000000000L, 0x28L, 0x0L); + case 68: + case 100: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0xfffffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000000L, 0x0L, 0x0L); + case 69: + case 101: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0xffff000000000000L, 0x3ffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L, 0x0L); + case 70: + case 102: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x7ffffc00L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 71: + case 103: + jjmatchedKind = 223; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x1fff00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 72: + case 104: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x7e00000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 73: + case 105: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0xfff8000000000000L, 0x7ffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2801000000000000L, 0x0L, 0x0L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x1ff80000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 75: + case 107: + jjmatchedKind = 285; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x1c0000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L, 0x0L); + case 76: + case 108: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffe00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000000L, 0x0L, 0x0L); + case 77: + case 109: + jjmatchedKind = 311; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0xff00000000000000L, 0x3fffffL, 0x0L, 0x8000000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 78: + case 110: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1fffffc00000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000000L, 0x0L, 0x0L); + case 79: + case 111: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xffffe00000000000L, 0x7fL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 80: + case 112: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1ffffffffff80L, 0x0L, 0x0L, 0x0L, 0x1000000000000000L, 0x1L, 0x0L); + case 81: + case 113: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80L, 0x0L); + case 82: + case 114: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffc000000000000L, 0x7ffffffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 83: + case 115: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffff800000000L, 0xffffffffffffffffL, 0xffffffL, 0x800000000000L, 0x14L, 0x0L); + case 84: + case 116: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffffffff000000L, 0x2000000000000L, 0x0L, 0x0L); + case 85: + case 117: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xf000000000000000L, 0xfffffL, 0x100L, 0x0L); + case 86: + case 118: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x20000007ff00000L, 0x0L, 0x0L); + case 87: + case 119: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2007ff80000000L, 0x0L, 0x0L); + case 88: + case 120: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80000000000L, 0x0L, 0x0L); + case 89: + case 121: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x300000000000L, 0x0L, 0x0L); + case 90: + case 122: + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000L, 0x0L, 0x0L); + case 123: + return jjStartNfaWithStates_3(0, 733, 77); + case 124: + jjmatchedKind = 759; + return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L); + case 125: + return jjStopAtPos(0, 734); + default : + return jjMoveNfa_3(0, 0); + } +} +private final int jjMoveStringLiteralDfa1_3(long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 1; + } + switch(curChar) + { + case 42: + if ((active12 & 0x8L) != 0L) + { + jjmatchedKind = 771; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0x1L); + case 46: + if ((active11 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 756); + break; + case 47: + if ((active12 & 0x2L) != 0L) + return jjStopAtPos(1, 769); + break; + case 58: + if ((active11 & 0x400000000000000L) != 0L) + return jjStopAtPos(1, 762); + break; + case 61: + if ((active11 & 0x20000000000L) != 0L) + return jjStopAtPos(1, 745); + else if ((active11 & 0x40000000000L) != 0L) + return jjStopAtPos(1, 746); + else if ((active11 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 748); + break; + case 62: + if ((active11 & 0x80000000000L) != 0L) + return jjStopAtPos(1, 747); + else if ((active11 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 755); + break; + case 65: + case 97: + return jjMoveStringLiteralDfa2_3(active0, 0x1ff0000000000000L, active1, 0L, active2, 0x10000000007f0L, active3, 0x200000000400L, active4, 0xff0000fe00080000L, active5, 0x7c00000L, active6, 0xc0000007fff80L, active7, 0x800000000L, active8, 0L, active9, 0x7000000L, active10, 0x13c400000ff00000L, active11, 0x1L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa2_3(active0, 0x70L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa2_3(active0, 0x80L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1c00018000000L, active6, 0L, active7, 0x1ff000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x4L, active12, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa2_3(active0, 0x700L, active1, 0L, active2, 0L, active3, 0x8000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa2_3(active0, 0xe00007e000000000L, active1, 0L, active2, 0x3fffff800L, active3, 0xf00000800L, active4, 0x1f01c0000000L, active5, 0xe000007fL, active6, 0xfff000003f800000L, active7, 0x7fffe000001fffffL, active8, 0L, active9, 0x1000000008000000L, active10, 0x2b000b0000000L, active11, 0x10L, active12, 0L); + case 70: + case 102: + if ((active5 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 369; + jjmatchedPos = 1; + } + else if ((active10 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(1, 688, 78); + return jjMoveStringLiteralDfa2_3(active0, 0x800L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x4000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000000000000L, active11, 0L, active12, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x10000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0x7ffL, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1L, active9, 0x10000000L, active10, 0x700000000L, active11, 0L, active12, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa2_3(active0, 0x380000000000L, active1, 0L, active2, 0x7c00000000L, active3, 0x40000000f000L, active4, 0x1e00000000000L, active5, 0x3f80L, active6, 0x40000000L, active7, 0x8000000000200000L, active8, 0xeL, active9, 0x1fe0000000L, active10, 0xf840000000L, active11, 0x2L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa2_3(active0, 0x40000001f000L, active1, 0x7800L, active2, 0x6000000000000L, active3, 0x20001000030000L, active4, 0L, active5, 0x8000000000000L, active6, 0x380000000L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x8000000000000L, active3, 0x3c0000000000000L, active4, 0L, active5, 0x10000000000000L, active6, 0L, active7, 0L, active8, 0x20L, active9, 0L, active10, 0x80000000000L, active11, 0L, active12, 0L); + case 78: + case 110: + if ((active3 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 250; + jjmatchedPos = 1; + } + else if ((active4 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(1, 305, 78); + else if ((active5 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 373; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0x60000L, active1, 0L, active2, 0x1f0000000000000L, active3, 0xf800000000000000L, active4, 0x7fffL, active5, 0xc0000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe000000000000000L, active10, 0x2c0000000000007fL, active11, 0L, active12, 0L); + case 79: + case 111: + if ((active3 & 0x2000000000L) != 0L) + { + jjmatchedKind = 229; + jjmatchedPos = 1; + } + else if ((active5 & 0x100000000L) != 0L) + { + jjmatchedKind = 352; + jjmatchedPos = 1; + } + else if ((active9 & 0x2000000000L) != 0L) + { + jjmatchedKind = 613; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0x1800000000000L, active1, 0x1ffffffff8000L, active2, 0xf8000000000L, active3, 0x7804000fc0000L, active4, 0x7c000000100000L, active5, 0x1e000fc000L, active6, 0x3c00000000L, active7, 0x3ff800000L, active8, 0xc0L, active9, 0x4000000000L, active10, 0xc000410000000000L, active11, 0x28L, active12, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa2_3(active0, 0x80000L, active1, 0L, active2, 0x200000000000000L, active3, 0L, active4, 0L, active5, 0x700000000000000L, active6, 0L, active7, 0L, active8, 0xf00L, active9, 0L, active10, 0x380L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x400000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xfffffffffffff000L, active9, 0x3L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active5 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 379; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0x2000001f00000L, active1, 0x6000000000000L, active2, 0x800100000000000L, active3, 0x1f800f000000L, active4, 0L, active5, 0x7000000000000000L, active6, 0xffc000000000L, active7, 0L, active8, 0L, active9, 0x3ffff8000000000L, active10, 0x20060000000000L, active11, 0L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + else if ((active4 & 0x8000L) != 0L) + { + jjmatchedKind = 271; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0x7c000000L, active1, 0L, active2, 0x1000000000000000L, active3, 0L, active4, 0x1fe70000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x1fc00L, active11, 0x40L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_3(active0, 0x700000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000006000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xffcL, active10, 0x100000000e0000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa2_3(active0, 0x800000000L, active1, 0xfff8000000000000L, active2, 0x7L, active3, 0x70000000L, active4, 0L, active5, 0x1f8000300000L, active6, 0x3000000000007L, active7, 0x400000000L, active8, 0L, active9, 0x4000000000ff000L, active10, 0L, active11, 0x180L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa2_3(active0, 0x1000000000L, active1, 0L, active2, 0x2000000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x78L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0xc000000000000000L, active3, 0x3ffL, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(1, 50, 78); + return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0xe00000000008L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800000000f00000L, active10, 0L, active11, 0L, active12, 0L); + case 124: + if ((active11 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 754); + break; + default : + break; + } + return jjStartNfa_3(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa2_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_3(0, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 2; + } + switch(curChar) + { + case 43: + if ((active12 & 0x1L) != 0L) + return jjStopAtPos(2, 768); + break; + case 65: + case 97: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_3(2, 8, 78); + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0x9bffL, active2, 0x400000800L, active3, 0x18003000000L, active4, 0x30000000000L, active5, 0x1L, active6, 0x72000180000000L, active7, 0x203000000000L, active8, 0x120L, active9, 0x1ff800000003cL, active10, 0x320000000400L, active11, 0x4L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0x8000000010000L, active2, 0L, active3, 0L, active4, 0x200200000000L, active5, 0L, active6, 0x1000000000000L, active7, 0L, active8, 0L, active9, 0x200000000703f000L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(2, 26, 78); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0xd01100000000e008L, active3, 0x3800000000000003L, active4, 0x3c000000000000L, active5, 0x400000000080L, active6, 0x80000000000000L, active7, 0x3c00000000000L, active8, 0L, active9, 0xc000000000040000L, active10, 0x4c4000000000000L, active11, 0L, active12, 0L); + case 68: + case 100: + if ((active0 & 0x200L) != 0L) + return jjStartNfaWithStates_3(2, 9, 78); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(2, 17, 78); + else if ((active2 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 181; + jjmatchedPos = 2; + } + else if ((active5 & 0x4000L) != 0L) + { + jjmatchedKind = 334; + jjmatchedPos = 2; + } + else if ((active5 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(2, 371, 78); + else if ((active6 & 0x80L) != 0L) + return jjStartNfaWithStates_3(2, 391, 78); + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0x1c0000000000000L, active3, 0x4000000000000000L, active4, 0L, active5, 0x7000000000018000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x800000800000081L, active11, 0L, active12, 0L); + case 69: + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(2, 20, 78); + else if ((active5 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(2, 374, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x2000008000000L, active1, 0x2000000000400L, active2, 0x2002000000000000L, active3, 0x840000400000cL, active4, 0L, active5, 0x100000000000000L, active6, 0xfc000000078L, active7, 0x4000000000000L, active8, 0xe00L, active9, 0x2000030000000L, active10, 0x7c000f800L, active11, 0x80L, active12, 0L); + case 70: + case 102: + if ((active6 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 440; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x2000000000L, active1, 0L, active2, 0x7f0000L, active3, 0L, active4, 0x40000000000L, active5, 0x4000000000000L, active6, 0x600000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000000e0000L, active11, 0L, active12, 0L); + case 71: + case 103: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(2, 36, 78); + else if ((active4 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(2, 290, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x9c000000000L, active1, 0L, active2, 0x800000L, active3, 0L, active4, 0L, active5, 0L, active6, 0xf800000000000000L, active7, 0x20000fL, active8, 0L, active9, 0L, active10, 0x4000000000000000L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000002008000000L, active6, 0L, active7, 0xc000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 73: + case 105: + if ((active6 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(2, 417, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x6000000000000000L, active1, 0L, active2, 0L, active3, 0x8020000000000010L, active4, 0x100001L, active5, 0x10004000000000L, active6, 0x700000000000L, active7, 0x400000L, active8, 0x10L, active9, 0xfc000000000000L, active10, 0x20040000010006L, active11, 0x100L, active12, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0xc00000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L, active12, 0L); + case 76: + case 108: + if ((active0 & 0x1000L) != 0L) + { + jjmatchedKind = 12; + jjmatchedPos = 2; + } + else if ((active8 & 0x1000L) != 0L) + { + jjmatchedKind = 524; + jjmatchedPos = 2; + } + else if ((active10 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(2, 683, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x30000000006000L, active1, 0x1fe0000L, active2, 0x1000000L, active3, 0x800010041400L, active4, 0L, active5, 0x80078010100300L, active6, 0L, active7, 0x18000003800030L, active8, 0xffffffffffffe000L, active9, 0x1L, active10, 0xa200000000700000L, active11, 0x2L, active12, 0L); + case 77: + case 109: + if ((active9 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(2, 595, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x400L, active1, 0x1000001e000000L, active2, 0x8000000000L, active3, 0xc0000000000000L, active4, 0x1000000000000L, active5, 0x180000e00002L, active6, 0L, active7, 0L, active8, 0x46L, active9, 0x400000fc8100000L, active10, 0x2800000000000L, active11, 0x20L, active12, 0L); + case 78: + case 110: + if ((active5 & 0x400L) != 0L) + { + jjmatchedKind = 330; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x8000100000000000L, active1, 0xfffe0000000L, active2, 0xe00002000000L, active3, 0x10000320002000L, active4, 0x80800000002L, active5, 0x201063800L, active6, 0xc000000000000L, active7, 0x8020000400000000L, active8, 0L, active9, 0x1000000000L, active10, 0x401000000060L, active11, 0x8L, active12, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa3_3(active0, 0xc00100000000L, active1, 0x4000000006000L, active2, 0x200100000000000L, active3, 0x1e1408030000L, active4, 0x1fe70004L, active5, 0L, active6, 0x800000000000L, active7, 0xf0000000000L, active8, 0x1L, active9, 0L, active10, 0x10000000000000L, active11, 0L, active12, 0L); + case 80: + case 112: + if ((active3 & 0x20L) != 0L) + { + jjmatchedKind = 197; + jjmatchedPos = 2; + } + else if ((active3 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(2, 240, 78); + else if ((active4 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(2, 312, 78); + return jjMoveStringLiteralDfa3_3(active0, 0x80000L, active1, 0L, active2, 0x8000004000000L, active3, 0x300000000000040L, active4, 0x8L, active5, 0L, active6, 0L, active7, 0x400000000000c0L, active8, 0L, active9, 0x800004000000000L, active10, 0x110L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active3 & 0x80000L) != 0L) + { + jjmatchedKind = 211; + jjmatchedPos = 2; + } + else if ((active6 & 0x800000L) != 0L) + { + jjmatchedKind = 407; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x40020001e00000L, active1, 0xffe0300000000000L, active2, 0x800000018000007L, active3, 0x70c000L, active4, 0x1000000000L, active5, 0xc00080004L, active6, 0x43f01ff00L, active7, 0x700100000000000L, active8, 0L, active9, 0x702L, active10, 0x100001003f800000L, active11, 0x10L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x10L) != 0L) + { + jjmatchedKind = 4; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x780000030000060L, active1, 0L, active2, 0x40079e0000000L, active3, 0x40000000L, active4, 0x60000000f0L, active5, 0x20000038L, active6, 0x18001e0000L, active7, 0x1800000000001f00L, active8, 0L, active9, 0x1000000000e00000L, active10, 0x200L, active11, 0x1L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(2, 45, 78); + else if ((active2 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(2, 168, 78); + else if ((active3 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(2, 227, 78); + else if ((active4 & 0x100L) != 0L) + { + jjmatchedKind = 264; + jjmatchedPos = 2; + } + else if ((active5 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(2, 356, 78); + else if ((active6 & 0x1L) != 0L) + { + jjmatchedKind = 384; + jjmatchedPos = 2; + } + else if ((active7 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 509; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x1801040e00008880L, active1, 0L, active2, 0x2000001f0L, active3, 0x4000000b80L, active4, 0x3e00008000003e00L, active5, 0x601800006000040L, active6, 0x600006L, active7, 0x40000000000fe000L, active8, 0L, active9, 0L, active10, 0x10000e000000000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0x400000000000L, active2, 0x400020000000000L, active3, 0x6000000800000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000000L, active8, 0x80L, active9, 0x300000000000000L, active10, 0L, active11, 0L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0x1800000000000L, active2, 0L, active3, 0x200000000000L, active4, 0x100000084000L, active5, 0L, active6, 0x40000000L, active7, 0x800100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 87: + case 119: + if ((active2 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(2, 170, 78); + else if ((active5 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(2, 350, 78); + else if ((active7 & 0x40000000L) != 0L) + { + jjmatchedKind = 478; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x40000000000000L, active5, 0L, active6, 0x2000000000L, active7, 0x380000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + if ((active4 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 318; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x80000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(2, 18, 78); + else if ((active2 & 0x200L) != 0L) + { + jjmatchedKind = 137; + jjmatchedPos = 2; + } + else if ((active2 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(2, 171, 78); + else if ((active4 & 0x40000000L) != 0L) + { + jjmatchedKind = 286; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_3(active0, 0x40000000L, active1, 0L, active2, 0x400L, active3, 0L, active4, 0x180000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800L, active10, 0L, active11, 0x40L, active12, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa3_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + default : + break; + } + return jjStartNfa_3(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa3_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_3(1, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 3; + } + switch(curChar) + { + case 45: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 49: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x40000L, active11, 0L); + case 51: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000L, active11, 0L); + case 56: + if ((active10 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(3, 657, 78); + break; + case 95: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0x180000000000000L, active3, 0L, active4, 0x180000000L, active5, 0x2000000000L, active6, 0L, active7, 0x180000000L, active8, 0xffffffffffff0000L, active9, 0x4000000001L, active10, 0x1800000L, active11, 0L); + case 65: + case 97: + if ((active2 & 0x10L) != 0L) + { + jjmatchedKind = 132; + jjmatchedPos = 3; + } + else if ((active4 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(3, 275, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x1802100001e10000L, active1, 0x3800000000000L, active2, 0x1400e08800032020L, active3, 0x12000L, active4, 0x3c000000000000L, active5, 0x8000000L, active6, 0x7f00L, active7, 0x40000000000010L, active8, 0L, active9, 0x2000000000000L, active10, 0x11000000000000a0L, active11, 0L); + case 66: + case 98: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(3, 46, 78); + else if ((active1 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(3, 77, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0x20000000000L, active3, 0x1000000000L, active4, 0L, active5, 0x80000000002L, active6, 0L, active7, 0L, active8, 0L, active9, 0x400000000000000L, active10, 0x2000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x20000000L) != 0L) + { + jjmatchedKind = 157; + jjmatchedPos = 3; + } + else if ((active3 & 0x4L) != 0L) + { + jjmatchedKind = 194; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_3(active0, 0x180000000000000L, active1, 0x400L, active2, 0x2000011c0000000L, active3, 0x21000808L, active4, 0x3e00000000000000L, active5, 0L, active6, 0x81c08f020000L, active7, 0L, active8, 0xf00L, active9, 0x1000000000041000L, active10, 0x4000000L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(3, 239, 78); + else if ((active4 & 0x10000000000L) != 0L) + { + jjmatchedKind = 296; + jjmatchedPos = 3; + } + else if ((active6 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 436; + jjmatchedPos = 3; + } + else if ((active11 & 0x100L) != 0L) + return jjStartNfaWithStates_3(3, 712, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x40000000000000L, active1, 0xe0000000L, active2, 0L, active3, 0L, active4, 0x20000010000L, active5, 0L, active6, 0x20000000000000L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x1000000000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 57, 78); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 115, 78); + else if ((active2 & 0x40L) != 0L) + { + jjmatchedKind = 134; + jjmatchedPos = 3; + } + else if ((active2 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 178, 78); + else if ((active3 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(3, 218, 78); + else if ((active4 & 0x400000000000L) != 0L) + { + jjmatchedKind = 302; + jjmatchedPos = 3; + } + else if ((active5 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(3, 339, 78); + else if ((active5 & 0x400000L) != 0L) + { + jjmatchedKind = 342; + jjmatchedPos = 3; + } + else if ((active5 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(3, 353, 78); + else if ((active7 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(3, 471, 78); + else if ((active8 & 0x8L) != 0L) + return jjStartNfaWithStates_3(3, 515, 78); + else if ((active8 & 0x40L) != 0L) + return jjStartNfaWithStates_3(3, 518, 78); + else if ((active9 & 0x40000000L) != 0L) + { + jjmatchedKind = 606; + jjmatchedPos = 3; + } + else if ((active9 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 632, 78); + else if ((active9 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 635, 78); + else if ((active10 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(3, 686, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x10008820L, active1, 0x10000000000000L, active2, 0xc0000002090c0180L, active3, 0xc0000300200180L, active4, 0x40908200001e32L, active5, 0xb001b00000800000L, active6, 0x600002000000002L, active7, 0x800c800000160L, active8, 0x2000L, active9, 0xf80000100L, active10, 0x800000000000341L, active11, 0L); + case 70: + case 102: + if ((active7 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 500, 78); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0x400000000L, active3, 0L, active4, 0x81800000000L, active5, 0x4L, active6, 0x4000000000000L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x4000000000000400L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 48, 78); + else if ((active2 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 176, 78); + else if ((active6 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(3, 405, 78); + else if ((active10 & 0x2000000000L) != 0L) + { + jjmatchedKind = 677; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_3(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x40L, active6, 0L, active7, 0x200000L, active8, 0L, active9, 0L, active10, 0xc000c000000000L, active11, 0L); + case 73: + case 105: + if ((active10 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(3, 687, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x9c020000480L, active1, 0x1L, active2, 0x10704000L, active3, 0x4000200040000000L, active4, 0x1000000000000L, active5, 0x4600000002008000L, active6, 0x1810000000L, active7, 0x100000000000000L, active8, 0x2L, active9, 0x8000000200L, active10, 0x2008000000000010L, active11, 0L); + case 75: + case 107: + if ((active6 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 435, 78); + else if ((active7 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 498, 78); + else if ((active10 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(3, 671, 78); + else if ((active10 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(3, 680, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x20000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0x4000000000000L, active11, 0L); + case 76: + case 108: + if ((active0 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + } + else if ((active0 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 61; + jjmatchedPos = 3; + } + else if ((active3 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(3, 220, 78); + else if ((active5 & 0x8000000000L) != 0L) + { + jjmatchedKind = 359; + jjmatchedPos = 3; + } + else if ((active6 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 438, 78); + else if ((active11 & 0x2L) != 0L) + return jjStartNfaWithStates_3(3, 705, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x4020800000080000L, active1, 0x7e8000L, active2, 0x8808L, active3, 0x1900000000040043L, active4, 0x40000L, active5, 0x74000000300L, active6, 0x1000000000000L, active7, 0x3003000080L, active8, 0x20L, active9, 0x7000800L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active3 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(3, 219, 78); + else if ((active9 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 630; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_3(active0, 0x140000000L, active1, 0x1e000000L, active2, 0x2000000000000L, active3, 0x402100000L, active4, 0L, active5, 0xc00000000L, active6, 0x100020000000L, active7, 0L, active8, 0L, active9, 0x80000000102000L, active10, 0x10000000000000L, active11, 0L); + case 78: + case 110: + if ((active4 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(3, 276, 78); + else if ((active4 & 0x200000L) != 0L) + { + jjmatchedKind = 277; + jjmatchedPos = 3; + } + else if ((active5 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 376, 78); + else if ((active6 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(3, 416, 78); + else if ((active9 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(3, 604, 78); + else if ((active10 & 0x100000000L) != 0L) + { + jjmatchedKind = 672; + jjmatchedPos = 3; + } + else if ((active11 & 0x4L) != 0L) + return jjStartNfaWithStates_3(3, 706, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x20008000000L, active1, 0x400700000000L, active2, 0L, active3, 0x8018000800000L, active4, 0x1fc00000L, active5, 0L, active6, 0L, active7, 0x400000000L, active8, 0L, active9, 0x201ff0000000000L, active10, 0x200010008L, active11, 0x40L); + case 79: + case 111: + if ((active3 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(3, 230, 78); + else if ((active4 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(3, 269, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x2000006040L, active1, 0x10000L, active2, 0x810000000000000L, active3, 0x210000000020000L, active4, 0x4000L, active5, 0x11000000L, active6, 0x200040000000L, active7, 0xd00000100000L, active8, 0L, active9, 0xe000000000000000L, active10, 0x8000000000000002L, active11, 0L); + case 80: + case 112: + if ((active2 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(3, 172, 78); + else if ((active8 & 0x10L) != 0L) + return jjStartNfaWithStates_3(3, 516, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0x2000000000L, active3, 0L, active4, 0L, active5, 0x200000L, active6, 0x20000000004L, active7, 0xf0000000200L, active8, 0x4L, active9, 0x8000000L, active10, 0x2020000000000L, active11, 0x20L); + case 81: + case 113: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x2L) != 0L) + { + jjmatchedKind = 65; + jjmatchedPos = 3; + } + else if ((active1 & 0x100000000000L) != 0L) + { + jjmatchedKind = 108; + jjmatchedPos = 3; + } + else if ((active3 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 241; + jjmatchedPos = 3; + } + else if ((active6 & 0x8L) != 0L) + { + jjmatchedKind = 387; + jjmatchedPos = 3; + } + else if ((active10 & 0x800L) != 0L) + { + jjmatchedKind = 651; + jjmatchedPos = 3; + } + else if ((active10 & 0x100000000000L) != 0L) + { + jjmatchedKind = 684; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_3(active0, 0x600000000L, active1, 0xffe02000000003fcL, active2, 0x2000000000800001L, active3, 0x2004400000000200L, active4, 0x200000000000L, active5, 0x80L, active6, 0xf802000000000070L, active7, 0x20000000000fL, active8, 0x80L, active9, 0x4L, active10, 0x40020040000f000L, active11, 0x80L); + case 83: + case 115: + if ((active2 & 0x400L) != 0L) + return jjStartNfaWithStates_3(3, 138, 78); + else if ((active7 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(3, 481, 78); + else if ((active7 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 510, 78); + else if ((active9 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(3, 605, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0x401f800005800L, active2, 0x2000006L, active3, 0xc410L, active4, 0L, active5, 0x4000000000039L, active6, 0x400000c0000L, active7, 0x1820000000000000L, active8, 0x4000L, active9, 0x3c000L, active10, 0x30000000L, active11, 0x1L); + case 84: + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 58, 78); + else if ((active4 & 0x2000000000L) != 0L) + { + jjmatchedKind = 293; + jjmatchedPos = 3; + } + else if ((active4 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(3, 298, 78); + else if ((active5 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(3, 351, 78); + else if ((active5 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 372, 78); + else if ((active6 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(3, 404, 78); + else if ((active9 & 0x2L) != 0L) + return jjStartNfaWithStates_3(3, 577, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x8000000000000000L, active1, 0x60000000000L, active2, 0x8004004000000L, active3, 0x8000000000401000L, active4, 0x40000000c1L, active5, 0x20160000L, active6, 0x400418000L, active7, 0x100003c000c00L, active8, 0L, active9, 0xe00038L, active10, 0x20040800000000L, active11, 0x8L); + case 85: + case 117: + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0x1800000L, active2, 0L, active3, 0x1e0000000000L, active4, 0xcL, active5, 0x400004011800L, active6, 0x80000000000000L, active7, 0x80820000000ff000L, active8, 0L, active9, 0x400L, active10, 0x200000000700000L, active11, 0L); + case 86: + case 118: + if ((active6 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(3, 427, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0x80000000000L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x2000L, active6, 0x400000000000L, active7, 0x600000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x10L); + case 87: + case 119: + if ((active8 & 0x1L) != 0L) + return jjStartNfaWithStates_3(3, 512, 78); + else if ((active10 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(3, 670, 78); + return jjMoveStringLiteralDfa4_3(active0, 0x40000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active5 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(3, 375, 78); + return jjMoveStringLiteralDfa4_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x20000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000L, active10, 0x8000000L, active11, 0L); + default : + break; + } + return jjStartNfa_3(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa4_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(2, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 4; + } + switch(curChar) + { + case 50: + if ((active10 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(4, 659, 78); + break; + case 54: + if ((active10 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(4, 658, 78); + break; + case 95: + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0x10000000000004L, active2, 0L, active3, 0x1000000L, active4, 0x80401fc00000L, active5, 0L, active6, 0xf800000000000000L, active7, 0xfL, active8, 0L, active9, 0x80000000000000L, active10, 0x10000000000f000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa5_3(active0, 0x180000000000000L, active1, 0x200063e03f8L, active2, 0x2000008000L, active3, 0x401000100240L, active4, 0x80002000000400c0L, active5, 0x10c00002038L, active6, 0x120000020000L, active7, 0x1000010000004e0L, active8, 0x8000L, active9, 0x1000000000000100L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active5 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(4, 348, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0x20L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1000000L, active8, 0x1f0000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active11 & 0x40L) != 0L) + return jjStartNfaWithStates_3(4, 710, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x2000L, active1, 0L, active2, 0L, active3, 0x4000000000000000L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0x8200080000000L, active8, 0x600080L, active9, 0x200000000000400L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(4, 215, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x2000000000000L, active1, 0L, active2, 0x10000000002000L, active3, 0xc0000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active1 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(4, 78, 78); + else if ((active2 & 0x8L) != 0L) + return jjStartNfaWithStates_3(4, 131, 78); + else if ((active3 & 0x400L) != 0L) + return jjStartNfaWithStates_3(4, 202, 78); + else if ((active3 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 245, 78); + else if ((active4 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(4, 292, 78); + else if ((active5 & 0x4L) != 0L) + return jjStartNfaWithStates_3(4, 322, 78); + else if ((active5 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(4, 358, 78); + else if ((active6 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 434, 78); + else if ((active7 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(4, 470, 78); + else if ((active7 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(4, 485, 78); + else if ((active7 & 0x10000000000L) != 0L) + { + jjmatchedKind = 488; + jjmatchedPos = 4; + } + else if ((active8 & 0x100L) != 0L) + return jjStartNfaWithStates_3(4, 520, 78); + else if ((active9 & 0x8L) != 0L) + { + jjmatchedKind = 579; + jjmatchedPos = 4; + } + else if ((active9 & 0x800L) != 0L) + return jjStartNfaWithStates_3(4, 587, 78); + else if ((active9 & 0x1000000L) != 0L) + { + jjmatchedKind = 600; + jjmatchedPos = 4; + } + else if ((active10 & 0x400L) != 0L) + return jjStartNfaWithStates_3(4, 650, 78); + else if ((active10 & 0x100000L) != 0L) + { + jjmatchedKind = 660; + jjmatchedPos = 4; + } + else if ((active10 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(4, 674, 78); + else if ((active10 & 0x40000000000L) != 0L) + { + jjmatchedKind = 682; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_3(active0, 0x20840000000000L, active1, 0xffe0280700408000L, active2, 0x42000002800001L, active3, 0x2100000402001000L, active4, 0x20000L, active5, 0x4080000000202L, active6, 0x84c00f400000L, active7, 0x6800e0000000200L, active8, 0L, active9, 0x6f440d0L, active10, 0x2e0000200600000L, active11, 0L); + case 70: + case 102: + if ((active2 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(4, 155, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0L, active5, 0x8000L, active6, 0L, active7, 0L, active8, 0x4000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active10 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(4, 656, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x20000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x200L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(4, 154, 78); + else if ((active2 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 185, 78); + else if ((active3 & 0x800L) != 0L) + return jjStartNfaWithStates_3(4, 203, 78); + else if ((active4 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 313; + jjmatchedPos = 4; + } + else if ((active5 & 0x20000L) != 0L) + { + jjmatchedKind = 337; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x3c00000000000000L, active5, 0x40000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x804000000L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa5_3(active0, 0x4040000700000000L, active1, 0x400f8000000L, active2, 0xc000000000L, active3, 0x8000000000200000L, active4, 0x20000000001L, active5, 0x20020100100L, active6, 0x1410480058000L, active7, 0x182100043c000000L, active8, 0x1fff8000e00L, active9, 0x1000000020L, active10, 0x401000403a000000L, active11, 0x18L); + case 75: + case 107: + if ((active1 & 0x400L) != 0L) + return jjStartNfaWithStates_3(4, 74, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000L, active5, 0L, active6, 0L, active7, 0x100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 76: + case 108: + if ((active1 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(4, 80, 78); + else if ((active3 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(4, 205, 78); + else if ((active4 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(4, 289, 78); + else if ((active4 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(4, 300, 78); + else if ((active4 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 306; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_3(active0, 0x1800000000000040L, active1, 0L, active2, 0x400020800000800L, active3, 0L, active4, 0x18000000000000L, active5, 0x10000L, active6, 0x30L, active7, 0x100000001000L, active8, 0xe0000000026L, active9, 0x40000c000001000L, active10, 0x1002000000000000L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa5_3(active0, 0x40000000L, active1, 0x1800000L, active2, 0xe00000004000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0x7f00L, active7, 0xc000000000L, active8, 0L, active9, 0x4000000000000000L, active10, 0x20L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x400L) != 0L) + return jjStartNfaWithStates_3(4, 10, 78); + else if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 4; + } + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_3(4, 64, 78); + else if ((active10 & 0x2L) != 0L) + return jjStartNfaWithStates_3(4, 641, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x98000000020L, active1, 0L, active2, 0x400700000L, active3, 0x200000000080L, active4, 0x10L, active5, 0x4000000000000000L, active6, 0L, active7, 0xc00100000000L, active8, 0xf00000000000L, active9, 0x8000000000000200L, active10, 0x2008000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa5_3(active0, 0x20800000080L, active1, 0L, active2, 0x1000000006L, active3, 0x40040000L, active4, 0x10000L, active5, 0x6000000020000c0L, active6, 0x10000000L, active7, 0L, active8, 0L, active9, 0x8000000L, active10, 0x9000000008L, active11, 0L); + case 80: + case 112: + if ((active3 & 0x20000000000L) != 0L) + { + jjmatchedKind = 233; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0xd100000000000000L, active3, 0x1c0000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x800000000L, active8, 0L, active9, 0L, active10, 0x20000800000L, active11, 0L); + case 82: + case 114: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_3(4, 11, 78); + else if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(4, 15, 78); + else if ((active2 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 187, 78); + else if ((active3 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(4, 209, 78); + else if ((active4 & 0x2L) != 0L) + return jjStartNfaWithStates_3(4, 257, 78); + else if ((active4 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 310, 78); + else if ((active5 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(4, 347, 78); + else if ((active5 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 380; + jjmatchedPos = 4; + } + else if ((active6 & 0x2L) != 0L) + return jjStartNfaWithStates_3(4, 385, 78); + else if ((active6 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(4, 421, 78); + else if ((active6 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(4, 429, 78); + else if ((active10 & 0x1L) != 0L) + return jjStartNfaWithStates_3(4, 640, 78); + else if ((active10 & 0x100L) != 0L) + return jjStartNfaWithStates_3(4, 648, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x102010000000L, active1, 0x1800000000000L, active2, 0x3c00c0000L, active3, 0x210000300400100L, active4, 0x8000001c20L, active5, 0xa000500004000000L, active6, 0x680000000000040L, active7, 0x420000000fe800L, active8, 0x1000000000000L, active9, 0L, active10, 0x200L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 114, 78); + else if ((active3 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 242, 78); + else if ((active5 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(4, 341, 78); + else if ((active5 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(4, 343, 78); + else if ((active5 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(4, 362, 78); + else if ((active6 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 437, 78); + else if ((active7 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 511, 78); + else if ((active10 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(4, 685, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x8000000L, active1, 0x1800L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1000000L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x1ff0380000000L, active10, 0x1000040L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(4, 110, 78); + else if ((active3 & 0x4000L) != 0L) + { + jjmatchedKind = 206; + jjmatchedPos = 4; + } + else if ((active3 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(4, 208, 78); + else if ((active3 & 0x8000000000L) != 0L) + { + jjmatchedKind = 231; + jjmatchedPos = 4; + } + else if ((active4 & 0x4L) != 0L) + return jjStartNfaWithStates_3(4, 258, 78); + else if ((active4 & 0x8L) != 0L) + return jjStartNfaWithStates_3(4, 259, 78); + else if ((active4 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 304, 78); + else if ((active6 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(4, 414, 78); + else if ((active7 & 0x100L) != 0L) + return jjStartNfaWithStates_3(4, 456, 78); + else if ((active7 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(4, 469, 78); + else if ((active9 & 0x4L) != 0L) + return jjStartNfaWithStates_3(4, 578, 78); + else if ((active9 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 625, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0x201f800000000L, active2, 0x1000180L, active3, 0x8010020008010L, active4, 0x20080100000000L, active5, 0x1800000001800L, active6, 0x2001800080000L, active7, 0x10L, active8, 0x7ffc000000004000L, active9, 0x38000L, active10, 0x80L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa5_3(active0, 0x8000000000000000L, active1, 0L, active2, 0x30000L, active3, 0x180000000000000bL, active4, 0x800000000L, active5, 0x1L, active6, 0x20000004L, active7, 0x2000000L, active8, 0L, active9, 0x2000000000002000L, active10, 0x4000000000004L, active11, 0x20L); + case 86: + case 118: + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0x10000000L, active3, 0L, active4, 0L, active5, 0x2000000000L, active6, 0L, active7, 0L, active8, 0x8000000000000000L, active9, 0x1L, active10, 0x10L, active11, 0L); + case 87: + case 119: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(4, 14, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0x1L); + case 88: + case 120: + if ((active10 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 699, 78); + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(4, 19, 78); + else if ((active0 & 0x200000L) != 0L) + { + jjmatchedKind = 21; + jjmatchedPos = 4; + } + else if ((active2 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 179, 78); + else if ((active2 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(4, 189, 78); + else if ((active11 & 0x80L) != 0L) + return jjStartNfaWithStates_3(4, 711, 78); + return jjMoveStringLiteralDfa5_3(active0, 0x1c10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x400000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa5_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc00000000L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_3(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa5_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(3, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 5; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa6_3(active0, 0x18001c00000L, active1, 0x1800000001000L, active2, 0x2000000L, active3, 0x40002008000L, active4, 0x3000000000000000L, active5, 0x800000000000L, active6, 0L, active7, 0xe0000000000L, active8, 0L, active9, 0x2000000L, active10, 0x2e0000800400000L, active11, 0L); + case 65: + case 97: + if ((active7 & 0x4000000000L) != 0L) + { + jjmatchedKind = 486; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_3(active0, 0x800000002000L, active1, 0L, active2, 0x100000000004020L, active3, 0xc000000300400000L, active4, 0x8800c20001L, active5, 0x4000002004000000L, active6, 0x1800000000008030L, active7, 0x40008001000000L, active8, 0x8000000000804002L, active9, 0x2800f0000001001L, active10, 0x2000005000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa6_3(active0, 0x600000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x100000000L) != 0L) + { + jjmatchedKind = 32; + jjmatchedPos = 5; + } + else if ((active6 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 432, 78); + else if ((active9 & 0x20L) != 0L) + return jjStartNfaWithStates_3(5, 581, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0x7004003f8L, active2, 0L, active3, 0x200L, active4, 0L, active5, 0L, active6, 0x2000000000000000L, active7, 0x280L, active8, 0x300000002000L, active9, 0L, active10, 0x10000000000000L, active11, 0x10L); + case 68: + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 53, 78); + else if ((active3 & 0x80L) != 0L) + return jjStartNfaWithStates_3(5, 199, 78); + else if ((active5 & 0x40L) != 0L) + return jjStartNfaWithStates_3(5, 326, 78); + else if ((active6 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(5, 412, 78); + else if ((active7 & 0x400000000000L) != 0L) + { + jjmatchedKind = 494; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_3(active0, 0x180000000000000L, active1, 0x10000000000000L, active2, 0L, active3, 0x1800000000000003L, active4, 0L, active5, 0L, active6, 0x80c000000000L, active7, 0x800000000000L, active8, 0L, active9, 0x8000000000000000L, active10, 0xf000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(5, 37, 78); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 113, 78); + else if ((active2 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(5, 141, 78); + else if ((active2 & 0x100000L) != 0L) + { + jjmatchedKind = 148; + jjmatchedPos = 5; + } + else if ((active2 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(5, 151, 78); + else if ((active2 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(5, 152, 78); + else if ((active2 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(5, 169, 78); + else if ((active2 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 188, 78); + else if ((active3 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 244, 78); + else if ((active5 & 0x800L) != 0L) + { + jjmatchedKind = 331; + jjmatchedPos = 5; + } + else if ((active5 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(5, 336, 78); + else if ((active7 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(5, 468, 78); + else if ((active8 & 0x4L) != 0L) + return jjStartNfaWithStates_3(5, 514, 78); + else if ((active8 & 0x80L) != 0L) + return jjStartNfaWithStates_3(5, 519, 78); + else if ((active9 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 634, 78); + else if ((active10 & 0x4L) != 0L) + return jjStartNfaWithStates_3(5, 642, 78); + else if ((active10 & 0x80L) != 0L) + return jjStartNfaWithStates_3(5, 647, 78); + return jjMoveStringLiteralDfa6_3(active0, 0x40040000000L, active1, 0L, active2, 0x10600000L, active3, 0x10000000000L, active4, 0xc00000081004200L, active5, 0x1001000L, active6, 0x602000000007f00L, active7, 0L, active8, 0x1000001000000L, active9, 0x3c004000040000L, active10, 0x2000020000000020L, active11, 0L); + case 70: + case 102: + if ((active5 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(5, 361, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe00L, active9, 0x300000000000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active3 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(5, 237, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x200000L, active4, 0L, active5, 0x38L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active4 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(5, 299, 78); + else if ((active7 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(5, 493, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x200000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa6_3(active0, 0x8000000L, active1, 0x20000000800L, active2, 0x10e001c0000180L, active3, 0xc8080020000040L, active4, 0L, active5, 0x2000100000008000L, active6, 0x4000001800000040L, active7, 0x2000000000810L, active8, 0x1c000000070020L, active9, 0x8000008000L, active10, 0x8000000000000L, active11, 0L); + case 76: + case 108: + if ((active3 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(5, 228, 78); + else if ((active6 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(5, 401, 78); + else if ((active7 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(5, 492, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0x4L, active2, 0x800030000L, active3, 0L, active4, 0x8000000000000000L, active5, 0xc00002000L, active6, 0x400000000000L, active7, 0x100000000000000L, active8, 0x4480000L, active9, 0x1c00000002000L, active10, 0x1000000000000000L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100L) != 0L) + return jjStartNfaWithStates_3(5, 584, 78); + else if ((active9 & 0x200000L) != 0L) + { + jjmatchedKind = 597; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x2100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x4000000000c00010L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_3(5, 7, 78); + else if ((active1 & 0x800000L) != 0L) + { + jjmatchedKind = 87; + jjmatchedPos = 5; + } + else if ((active2 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(5, 167, 78); + else if ((active3 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(5, 222, 78); + else if ((active5 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 377; + jjmatchedPos = 5; + } + else if ((active7 & 0x2000L) != 0L) + { + jjmatchedKind = 461; + jjmatchedPos = 5; + } + else if ((active10 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(5, 678, 78); + return jjMoveStringLiteralDfa6_3(active0, 0x4040000020000000L, active1, 0xffe0040007000000L, active2, 0x2005000000001L, active3, 0x100L, active4, 0x200000000c0L, active5, 0x400000022000200L, active6, 0x8f040000L, active7, 0x8000043c0fc000L, active8, 0x1fff8000000L, active9, 0x2000001000000000L, active10, 0x400000000a000000L, active11, 0x8L); + case 79: + case 111: + return jjMoveStringLiteralDfa6_3(active0, 0x1800000000000000L, active1, 0L, active2, 0x400000800L, active3, 0L, active4, 0x20000006000000L, active5, 0L, active6, 0x400000000L, active7, 0x1801000880000000L, active8, 0xe0002100000L, active9, 0xc00000000L, active10, 0x30800010L, active11, 0x1L); + case 80: + case 112: + if ((active7 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(5, 473, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000000000L, active10, 0x404000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x2L) != 0L) + { + jjmatchedKind = 129; + jjmatchedPos = 5; + } + else if ((active3 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(5, 204, 78); + else if ((active5 & 0x2L) != 0L) + return jjStartNfaWithStates_3(5, 321, 78); + else if ((active5 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(5, 363, 78); + else if ((active7 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(5, 484, 78); + else if ((active7 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 505; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_3(active0, 0x8000000800000000L, active1, 0x9f800000000L, active2, 0x800000000c8004L, active3, 0x400000000000L, active4, 0xa00000000000L, active5, 0x400000000001L, active6, 0x8000160000400000L, active7, 0x400000000000400L, active8, 0x8000L, active9, 0x8030000L, active10, 0x100000000000000L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(5, 16, 78); + else if ((active2 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 186, 78); + else if ((active3 & 0x10L) != 0L) + return jjStartNfaWithStates_3(5, 196, 78); + else if ((active3 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(5, 236, 78); + else if ((active5 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(5, 338, 78); + else if ((active5 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 368, 78); + else if ((active5 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 383, 78); + else if ((active10 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(5, 661, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0x200000008000L, active2, 0L, active3, 0x1000000L, active4, 0xc10L, active5, 0x100180L, active6, 0x80010000000000L, active7, 0x2fL, active8, 0x7fe0000000000000L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_3(5, 5, 78); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(5, 43, 78); + else if ((active1 & 0x8000000L) != 0L) + { + jjmatchedKind = 91; + jjmatchedPos = 5; + } + else if ((active2 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 190; + jjmatchedPos = 5; + } + else if ((active3 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(5, 212, 78); + else if ((active3 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 249, 78); + else if ((active4 & 0x20L) != 0L) + return jjStartNfaWithStates_3(5, 261, 78); + else if ((active5 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(5, 365, 78); + else if ((active5 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 370, 78); + else if ((active6 & 0x4L) != 0L) + return jjStartNfaWithStates_3(5, 386, 78); + else if ((active7 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(5, 460, 78); + else if ((active7 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(5, 499, 78); + else if ((active9 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(5, 590, 78); + else if ((active10 & 0x40L) != 0L) + return jjStartNfaWithStates_3(5, 646, 78); + else if ((active10 & 0x200L) != 0L) + return jjStartNfaWithStates_3(5, 649, 78); + return jjMoveStringLiteralDfa6_3(active0, 0x2000010000000L, active1, 0xf03e0000L, active2, 0x8000002000000000L, active3, 0x400000008L, active4, 0x18000000040000L, active5, 0L, active6, 0x20010000L, active7, 0x20000000000040L, active8, 0L, active9, 0x380100400L, active10, 0L, active11, 0x20L); + case 85: + case 117: + return jjMoveStringLiteralDfa6_3(active0, 0x20000000040L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0x400000000000L, active9, 0L, active10, 0x8000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010001000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0xc0L, active10, 0x200000000L, active11, 0L); + case 87: + case 119: + if ((active4 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(5, 272, 78); + else if ((active10 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(5, 676, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x40000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(5, 44, 78); + return jjMoveStringLiteralDfa6_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_3(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa6_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(4, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 6; + } + switch(curChar) + { + case 50: + if ((active6 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 447, 78); + break; + case 95: + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0xc002c0L, active10, 0x2000000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa7_3(active0, 0x40000000400000L, active1, 0xf800000000L, active2, 0x80000000040000L, active3, 0xc0000000000100L, active4, 0x4010001000L, active5, 0x2000000L, active6, 0L, active7, 0x40L, active8, 0x3800000200000L, active9, 0x1c0038c000000L, active10, 0x2000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0x40000000L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x800000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x200000000000L) != 0L) + { + jjmatchedKind = 173; + jjmatchedPos = 6; + } + else if ((active5 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(6, 364, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x800000L, active1, 0x8000L, active2, 0xc06000000800L, active3, 0x440000000000L, active4, 0x40L, active5, 0x1000000L, active6, 0L, active7, 0x80020001000800L, active8, 0x1000000L, active9, 0xf0000000000L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active2 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(6, 149, 78); + else if ((active2 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(6, 156, 78); + else if ((active3 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(6, 232, 78); + else if ((active4 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 314, 78); + else if ((active10 & 0x20L) != 0L) + return jjStartNfaWithStates_3(6, 645, 78); + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0x6000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x40L, active7, 0L, active8, 0L, active9, 0x2000000000040000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 6; + } + else if ((active1 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(6, 81, 78); + else if ((active2 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(6, 143, 78); + else if ((active3 & 0x1L) != 0L) + return jjStartNfaWithStates_3(6, 192, 78); + else if ((active3 & 0x8L) != 0L) + return jjStartNfaWithStates_3(6, 195, 78); + else if ((active3 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 251, 78); + else if ((active6 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(6, 413, 78); + else if ((active6 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(6, 425, 78); + else if ((active7 & 0x20L) != 0L) + return jjStartNfaWithStates_3(6, 453, 78); + else if ((active7 & 0x80L) != 0L) + return jjStartNfaWithStates_3(6, 455, 78); + else if ((active7 & 0x4000000L) != 0L) + { + jjmatchedKind = 474; + jjmatchedPos = 6; + } + else if ((active9 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 636, 78); + else if ((active11 & 0x10L) != 0L) + return jjStartNfaWithStates_3(6, 708, 78); + else if ((active11 & 0x20L) != 0L) + return jjStartNfaWithStates_3(6, 709, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x100000000000000L, active1, 0x4L, active2, 0x40000000080000L, active3, 0x2100000001000000L, active4, 0x800000000c00L, active5, 0x4000001081b9L, active6, 0x404000000000L, active7, 0x3803c000L, active8, 0x2000L, active9, 0x10L, active10, 0x110000020000f000L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa7_3(active0, 0x8000000000L, active1, 0x800L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 59; + jjmatchedPos = 6; + } + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 62, 78); + else if ((active4 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(6, 297, 78); + else if ((active5 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(6, 349, 78); + else if ((active6 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(6, 402, 78); + else if ((active6 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(6, 415, 78); + else if ((active7 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(6, 482, 78); + else if ((active10 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(6, 667, 78); + else if ((active10 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 702, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x1000000000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 49, 78); + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x100000000000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa7_3(active0, 0x810000000L, active1, 0x100000e03c0000L, active2, 0x8000000200000000L, active3, 0x1000000000040002L, active4, 0x18000000040010L, active5, 0xc00000000L, active6, 0x80018000010000L, active7, 0x120000800040000L, active8, 0x7fe0000000000e00L, active9, 0xc000000000030000L, active10, 0x8010000000000000L, active11, 0L); + case 76: + case 108: + if ((active2 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(6, 142, 78); + else if ((active3 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(6, 224, 78); + else if ((active3 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 255; + jjmatchedPos = 6; + } + else if ((active4 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(6, 295, 78); + else if ((active5 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(6, 346, 78); + else if ((active6 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(6, 399, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x20000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1L, active5, 0x4000812000000000L, active6, 0L, active7, 0x1L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa7_3(active0, 0x21000000L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0xc400000000000L, active9, 0L, active10, 0x1000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(6, 42, 78); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(6, 47, 78); + else if ((active3 & 0x40L) != 0L) + return jjStartNfaWithStates_3(6, 198, 78); + else if ((active3 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(6, 213, 78); + else if ((active3 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(6, 214, 78); + else if ((active6 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(6, 406, 78); + else if ((active6 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(6, 418, 78); + else if ((active7 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 496, 78); + else if ((active7 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 507; + jjmatchedPos = 6; + } + else if ((active10 & 0x8L) != 0L) + return jjStartNfaWithStates_3(6, 643, 78); + else if ((active10 & 0x10000000L) != 0L) + { + jjmatchedKind = 668; + jjmatchedPos = 6; + } + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0x20000000000L, active2, 0x10001000000000L, active3, 0x80000000000L, active4, 0x1000000000000000L, active5, 0x2000000000000200L, active6, 0x4600000000000000L, active7, 0x1000040000000000L, active8, 0x100e0000028020L, active9, 0x8c02000000L, active10, 0x80000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0x1000L, active2, 0x800000000L, active3, 0x20000000L, active4, 0L, active5, 0L, active6, 0x2000001800000000L, active7, 0L, active8, 0x4580000L, active9, 0x300000000000L, active10, 0x400000L, active11, 0L); + case 80: + case 112: + if ((active10 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(6, 663, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x10000000000L, active1, 0xa00000000000L, active2, 0x180000000L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0x10L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(6, 150, 78); + else if ((active4 & 0x200L) != 0L) + return jjStartNfaWithStates_3(6, 265, 78); + else if ((active4 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(6, 270, 78); + else if ((active4 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(6, 273, 78); + else if ((active4 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 309, 78); + else if ((active6 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 433, 78); + else if ((active8 & 0x2L) != 0L) + return jjStartNfaWithStates_3(6, 513, 78); + else if ((active9 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 626; + jjmatchedPos = 6; + } + else if ((active10 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(6, 666, 78); + else if ((active10 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(6, 681, 78); + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0x100000002000000L, active3, 0x402000000L, active4, 0x2000000000c00000L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x8000000000000000L, active9, 0xb8000000100001L, active10, 0L, active11, 0x1L); + case 83: + case 115: + if ((active4 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 315, 78); + else if ((active5 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(6, 332, 78); + else if ((active5 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 378, 78); + else if ((active7 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(6, 467, 78); + else if ((active7 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(6, 495, 78); + else if ((active10 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 690, 78); + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0x1000000000000L, active2, 0x400000020L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0L, active9, 0x1000L, active10, 0x20000000000000L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(6, 86, 78); + else if ((active1 & 0x100000000L) != 0L) + { + jjmatchedKind = 96; + jjmatchedPos = 6; + } + else if ((active1 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(6, 107, 78); + else if ((active1 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 117; + jjmatchedPos = 6; + } + else if ((active2 & 0x10000L) != 0L) + { + jjmatchedKind = 144; + jjmatchedPos = 6; + } + else if ((active2 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 177, 78); + else if ((active3 & 0x200L) != 0L) + return jjStartNfaWithStates_3(6, 201, 78); + else if ((active6 & 0x1000000L) != 0L) + { + jjmatchedKind = 408; + jjmatchedPos = 6; + } + else if ((active7 & 0x200L) != 0L) + return jjStartNfaWithStates_3(6, 457, 78); + else if ((active7 & 0x400L) != 0L) + return jjStartNfaWithStates_3(6, 458, 78); + else if ((active8 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(6, 530, 78); + else if ((active9 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(6, 612, 78); + else if ((active10 & 0x10L) != 0L) + return jjStartNfaWithStates_3(6, 644, 78); + else if ((active10 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(6, 679, 78); + return jjMoveStringLiteralDfa7_3(active0, 0x48002040L, active1, 0xffc00006100003f8L, active2, 0x20001L, active3, 0x4008000200000000L, active4, 0x80L, active5, 0L, active6, 0xe007f00L, active7, 0x42000000000000L, active8, 0x1fff8804000L, active9, 0x20000000000a000L, active10, 0x60a000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa7_3(active0, 0x600000000L, active1, 0x50000000000L, active2, 0L, active3, 0L, active4, 0x8000000008000000L, active5, 0x2000L, active6, 0x800000000000L, active7, 0x80000000L, active8, 0x2000000L, active9, 0x400L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0x1800040000000000L, active7, 0x10L, active8, 0L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x6L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(6, 63, 78); + else if ((active4 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(6, 301, 78); + else if ((active6 & 0x20L) != 0L) + return jjStartNfaWithStates_3(6, 389, 78); + else if ((active6 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(6, 428, 78); + return jjMoveStringLiteralDfa7_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_3(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa7_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(5, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 7; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa8_3(active0, 0x1000000000000000L, active1, 0xffc0000006000000L, active2, 0xc00000000001L, active3, 0L, active4, 0L, active5, 0x38L, active6, 0x8000000L, active7, 0x1000000038000000L, active8, 0x7fe0000000000000L, active9, 0x38000000000000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa8_3(active0, 0x10001000000L, active1, 0x1000000000000L, active2, 0x2000800L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x60000000000L, active8, 0x100004020000L, active9, 0x2000200L, active10, 0x80000000000000L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(7, 531, 78); + else if ((active8 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(7, 534, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000040L, active8, 0x8000000002000000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 182, 80); + else if ((active8 & 0x200L) != 0L) + { + jjmatchedKind = 521; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0x10000000000L, active2, 0L, active3, 0x1000000L, active4, 0xc00L, active5, 0x180L, active6, 0x600000000000000L, active7, 0x80000000000L, active8, 0xc00L, active9, 0x1L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 56, 78); + else if ((active2 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(7, 147, 78); + else if ((active11 & 0x1L) != 0L) + return jjStartNfaWithStates_3(7, 704, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x40L) != 0L) + return jjStartNfaWithStates_3(7, 6, 78); + else if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(7, 13, 78); + else if ((active1 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(7, 79, 78); + else if ((active1 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(7, 106, 78); + else if ((active2 & 0x20L) != 0L) + return jjStartNfaWithStates_3(7, 133, 78); + else if ((active2 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(7, 158, 78); + else if ((active4 & 0x40L) != 0L) + return jjStartNfaWithStates_3(7, 262, 78); + else if ((active4 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(7, 288, 78); + else if ((active4 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(7, 291, 78); + else if ((active4 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 319, 78); + else if ((active5 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(7, 333, 78); + else if ((active5 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(7, 360, 78); + else if ((active6 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(7, 426, 78); + else if ((active7 & 0x10L) != 0L) + return jjStartNfaWithStates_3(7, 452, 78); + else if ((active7 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 503, 78); + else if ((active8 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(7, 526, 78); + else if ((active8 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(7, 535, 78); + else if ((active8 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 562; + jjmatchedPos = 7; + } + else if ((active9 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 633, 78); + else if ((active10 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 689, 78); + return jjMoveStringLiteralDfa8_3(active0, 0x20000000L, active1, 0x100003f8L, active2, 0x1000000180L, active3, 0x200000000L, active4, 0x2000000008000000L, active5, 0x800000000000L, active6, 0x7f00L, active7, 0L, active8, 0x841fff8000000L, active9, 0x2000004c00000000L, active10, 0x400000000000000L, active11, 0L); + case 70: + case 102: + if ((active10 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(7, 662, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L, active11, 0L); + case 71: + case 103: + if ((active2 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 180, 78); + else if ((active3 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(7, 235, 78); + else if ((active5 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 381, 78); + else if ((active9 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(7, 615, 78); + return jjMoveStringLiteralDfa8_3(active0, 0x400000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000000L, active5, 0L, active6, 0x1800400000000000L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0x100000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(7, 165, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x400000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa8_3(active0, 0x8000000L, active1, 0xfe00000800L, active2, 0L, active3, 0L, active4, 0x1000080L, active5, 0x4000000000000200L, active6, 0x6000040L, active7, 0L, active8, 0x1018000L, active9, 0x102000L, active10, 0x20000000L, active11, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active7 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(7, 472, 78); + break; + case 76: + case 108: + if ((active3 & 0x100L) != 0L) + return jjStartNfaWithStates_3(7, 200, 78); + else if ((active4 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(7, 268, 78); + else if ((active5 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(7, 345, 78); + else if ((active8 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 560, 78); + else if ((active10 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 700, 78); + return jjMoveStringLiteralDfa8_3(active0, 0x40020000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010000001L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000100000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0x18000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x384000000L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active3 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(7, 221, 78); + else if ((active6 & 0x800000000L) != 0L) + { + jjmatchedKind = 419; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0x1000004L, active2, 0x200000004L, active3, 0x3100000000040002L, active4, 0L, active5, 0x400000000000L, active6, 0x9000000000L, active7, 0x400008880040000L, active8, 0L, active9, 0x30010L, active10, 0x8000000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa8_3(active0, 0x10800000L, active1, 0xa000e03c0000L, active2, 0x8000000000000000L, active3, 0x4000040002000000L, active4, 0x40000L, active5, 0x1000000L, active6, 0x10000090000L, active7, 0x40000000000001L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0x8L); + case 80: + case 112: + if ((active10 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(7, 664, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0x40L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active8 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(7, 533, 78); + else if ((active10 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(7, 673, 78); + return jjMoveStringLiteralDfa8_3(active0, 0x8040000000L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0xc00000L, active5, 0L, active6, 0x800000000000L, active7, 0L, active8, 0x800000000000L, active9, 0x80300008000400L, active10, 0x40000002000000L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(7, 105, 78); + else if ((active2 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(7, 145, 78); + else if ((active5 & 0x1L) != 0L) + return jjStartNfaWithStates_3(7, 320, 78); + else if ((active5 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(7, 335, 78); + else if ((active6 & 0x10L) != 0L) + return jjStartNfaWithStates_3(7, 388, 78); + else if ((active6 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(7, 422, 78); + else if ((active9 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(7, 594, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0x10000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1080L, active10, 0x2000000000000000L, active11, 0L); + case 84: + case 116: + if ((active2 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(7, 166, 78); + else if ((active5 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(7, 340, 78); + else if ((active7 & 0x800L) != 0L) + return jjStartNfaWithStates_3(7, 459, 78); + else if ((active8 & 0x20L) != 0L) + return jjStartNfaWithStates_3(7, 517, 78); + return jjMoveStringLiteralDfa8_3(active0, 0x600000000L, active1, 0L, active2, 0x100000580000000L, active3, 0xc0000000000000L, active4, 0x10L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0xc001cf0000400000L, active10, 0x10000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0x2000000000L, active6, 0x2000000000000000L, active7, 0L, active8, 0L, active9, 0x808000L, active10, 0x800000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000000000000L, active7, 0x20000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active2 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(7, 163, 78); + break; + case 88: + case 120: + if ((active7 & 0x2L) != 0L) + return jjStartNfaWithStates_3(7, 449, 78); + break; + case 89: + case 121: + if ((active3 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(7, 226, 78); + else if ((active3 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 243, 78); + else if ((active7 & 0x4L) != 0L) + return jjStartNfaWithStates_3(7, 450, 78); + else if ((active7 & 0x8L) != 0L) + return jjStartNfaWithStates_3(7, 451, 78); + else if ((active7 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(7, 497, 78); + return jjMoveStringLiteralDfa8_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000000000000L, active9, 0L, active10, 0x228000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa8_3(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0xc00000000L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_3(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa8_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(6, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000000000L, active7, 0x3c000L, active8, 0x400L, active9, 0xc00001000L, active10, 0x8000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa9_3(active0, 0x8800000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0xc00080L, active5, 0L, active6, 0L, active7, 0x500008000000000L, active8, 0L, active9, 0x80000000000080L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(8, 557, 78); + break; + case 67: + case 99: + if ((active9 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(8, 596, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x40000000000000L, active2, 0x1000000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0x400000000000L, active6, 0L, active7, 0x8000000L, active8, 0x800000000000L, active9, 0x8000000000000L, active10, 0x800000000L, active11, 0L); + case 68: + case 100: + if ((active1 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(8, 92, 78); + else if ((active3 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(8, 225, 78); + else if ((active9 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 637, 78); + else if ((active10 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 698, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x180000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000L) != 0L) + { + jjmatchedKind = 33; + jjmatchedPos = 8; + } + else if ((active2 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 183, 78); + else if ((active3 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 246; + jjmatchedPos = 8; + } + else if ((active4 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 307; + jjmatchedPos = 8; + } + else if ((active5 & 0x400000000L) != 0L) + { + jjmatchedKind = 354; + jjmatchedPos = 8; + } + else if ((active5 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(8, 357, 78); + else if ((active6 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(8, 431, 78); + else if ((active6 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 439, 78); + else if ((active7 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 501, 78); + else if ((active9 & 0x400L) != 0L) + return jjStartNfaWithStates_3(8, 586, 78); + else if ((active9 & 0x400000000000L) != 0L) + { + jjmatchedKind = 622; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_3(active0, 0x400000000L, active1, 0x800L, active2, 0L, active3, 0x80000000000000L, active4, 0x10800086000000L, active5, 0x800000000L, active6, 0x4200400000000000L, active7, 0x100000000L, active8, 0x100000L, active9, 0x800000000000L, active10, 0L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(8, 22, 78); + else if ((active3 & 0x2L) != 0L) + return jjStartNfaWithStates_3(8, 193, 78); + else if ((active3 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(8, 210, 78); + else if ((active3 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 252, 78); + else if ((active6 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(8, 423, 78); + else if ((active7 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(8, 466, 78); + else if ((active9 & 0x10000L) != 0L) + { + jjmatchedKind = 592; + jjmatchedPos = 8; + } + else if ((active10 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 703, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x4L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000L, active9, 0x20200L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0x80000000000000L, active9, 0x1L, active10, 0L, active11, 0L); + case 73: + case 105: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(8, 41, 78); + return jjMoveStringLiteralDfa9_3(active0, 0x40000040000000L, active1, 0x1000L, active2, 0x100000680000000L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000000L, active9, 0x80010f0000400000L, active10, 0x210000000000f000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0x8000L, active4, 0L, active5, 0x8L, active6, 0x6000000L, active7, 0x40L, active8, 0x2000002000000L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100000000000L) != 0L) + { + jjmatchedKind = 620; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x1000000000000L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0L, active7, 0x40000000000L, active8, 0x700000001000000L, active9, 0x200002000000L, active10, 0x80000000000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(8, 28, 78); + else if ((active1 & 0x40000L) != 0L) + { + jjmatchedKind = 82; + jjmatchedPos = 8; + } + else if ((active1 & 0x20000000L) != 0L) + { + jjmatchedKind = 93; + jjmatchedPos = 8; + } + else if ((active2 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 191, 78); + else if ((active4 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(8, 274, 78); + else if ((active6 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(8, 400, 78); + else if ((active6 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(8, 424, 78); + return jjMoveStringLiteralDfa9_3(active0, 0x1000000020800000L, active1, 0x20f8c0380000L, active2, 0x2000000L, active3, 0x40000000000L, active4, 0L, active5, 0x800001000000L, active6, 0x2000000000000040L, active7, 0x10000000L, active8, 0x18000L, active9, 0x10000000000000L, active10, 0x20000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x600000000L, active2, 0x100000000L, active3, 0x1000000L, active4, 0L, active5, 0x190L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40L, active10, 0x40000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(8, 111, 78); + else if ((active9 & 0x80000000L) != 0L) + { + jjmatchedKind = 607; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x200000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1L, active8, 0L, active9, 0x304000000L, active10, 0x200000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 8; + } + else if ((active3 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 254, 78); + else if ((active6 & 0x100L) != 0L) + { + jjmatchedKind = 392; + jjmatchedPos = 8; + } + else if ((active7 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 502, 78); + else if ((active8 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_3(8, 556, 78); + return jjMoveStringLiteralDfa9_3(active0, 0x10000000000L, active1, 0xc000000000003f0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0x8007e00L, active7, 0L, active8, 0x41fff0020000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0x1008000000000000L, active9, 0x20000000802000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 116, 78); + else if ((active3 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 253, 78); + else if ((active4 & 0x400L) != 0L) + { + jjmatchedKind = 266; + jjmatchedPos = 8; + } + else if ((active7 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(8, 479, 78); + else if ((active7 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(8, 483, 78); + else if ((active8 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(8, 538, 78); + else if ((active9 & 0x10L) != 0L) + return jjStartNfaWithStates_3(8, 580, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0xe000010000000000L, active2, 0x800L, active3, 0x100000000000000L, active4, 0x800L, active5, 0x4000000000000020L, active6, 0L, active7, 0x20000000000L, active8, 0x2800L, active9, 0x4000000000008000L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x4010000000L, active5, 0x200L, active6, 0x80000L, active7, 0x1000000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa9_3(active0, 0x8000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active3 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(8, 217, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active6 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 443, 78); + return jjMoveStringLiteralDfa9_3(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active3 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(8, 238, 78); + else if ((active4 & 0x1L) != 0L) + return jjStartNfaWithStates_3(8, 256, 78); + else if ((active6 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 444, 78); + else if ((active9 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(8, 603, 78); + else if ((active10 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(8, 665, 78); + else if ((active10 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(8, 692, 78); + return jjMoveStringLiteralDfa9_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4000000000000000L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_3(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa9_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(7, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 9; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa10_3(active0, 0x1000000L, active1, 0x803800f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7e00L, active7, 0L, active8, 0L, active9, 0x804000020000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa10_3(active0, 0x1000000000000000L, active1, 0x2c0000040000000L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x8000000L, active7, 0x20018000000L, active8, 0x200e0001100000L, active9, 0x18000100000001L, active10, 0L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000080L, active5, 0L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(9, 30, 78); + return jjMoveStringLiteralDfa10_3(active0, 0x800000L, active1, 0x1000000000000000L, active2, 0x400000000L, active3, 0x40000000000L, active4, 0x6000000L, active5, 0x10L, active6, 0L, active7, 0x20004000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L, active11, 0L); + case 68: + case 100: + if ((active5 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(9, 344, 78); + else if ((active5 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(9, 355, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x200000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(9, 27, 78); + else if ((active2 & 0x800L) != 0L) + return jjStartNfaWithStates_3(9, 139, 78); + else if ((active2 & 0x40000L) != 0L) + return jjStartNfaWithStates_3(9, 146, 78); + else if ((active4 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(9, 284, 78); + else if ((active4 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(9, 294, 78); + else if ((active7 & 0x1L) != 0L) + return jjStartNfaWithStates_3(9, 448, 78); + else if ((active7 & 0x40L) != 0L) + return jjStartNfaWithStates_3(9, 454, 78); + else if ((active7 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(9, 490, 78); + else if ((active8 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(9, 537, 78); + else if ((active9 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(9, 591, 78); + else if ((active9 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(9, 601, 78); + else if ((active10 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 695, 78); + else if ((active10 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 697, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000028L, active6, 0x6000000L, active7, 0x80000000000L, active8, 0x7000000008000000L, active9, 0x4000000000802000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active6 & 0x40L) != 0L) + return jjStartNfaWithStates_3(9, 390, 78); + else if ((active8 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(9, 527, 78); + else if ((active9 & 0x200L) != 0L) + return jjStartNfaWithStates_3(9, 585, 78); + else if ((active10 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(9, 669, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x800000000000L, active6, 0x80000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0x400000000L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x6000000000000100L, active2, 0x180L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0L, active7, 0L, active8, 0x302400000002000L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active2 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(9, 153, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000800000000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x80000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active5 & 0x200L) != 0L) + return jjStartNfaWithStates_3(9, 329, 78); + return jjMoveStringLiteralDfa10_3(active0, 0x8000000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0x800400080L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active1 & 0x200000000L) != 0L) + { + jjmatchedKind = 97; + jjmatchedPos = 9; + } + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x400000000L, active2, 0L, active3, 0x1000000L, active4, 0L, active5, 0x180L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000400L, active9, 0L, active10, 0xf000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0xc00010000000000L, active2, 0x80000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x480000000000000L, active9, 0x80010f0000001000L, active10, 0x100000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 112, 78); + else if ((active9 & 0x40L) != 0L) + return jjStartNfaWithStates_3(9, 582, 78); + break; + case 82: + case 114: + if ((active1 & 0x800L) != 0L) + return jjStartNfaWithStates_3(9, 75, 78); + else if ((active2 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(9, 160, 78); + else if ((active4 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(9, 287, 78); + else if ((active7 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(9, 480, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000001000000000L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(9, 34, 78); + else if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_3(9, 73, 78); + else if ((active6 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(9, 430, 78); + else if ((active6 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 441, 78); + else if ((active9 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(9, 621, 78); + else if ((active11 & 0x8L) != 0L) + return jjStartNfaWithStates_3(9, 707, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0x200000001L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0L, active7, 0x1000000000020000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(9, 29, 78); + else if ((active1 & 0x800000000L) != 0L) + { + jjmatchedKind = 99; + jjmatchedPos = 9; + } + else if ((active2 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(9, 164, 78); + else if ((active6 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 445, 78); + else if ((active8 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(9, 528, 78); + return jjMoveStringLiteralDfa10_3(active0, 0x40010800000000L, active1, 0xf000000004L, active2, 0x100000000000000L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1fff0000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active4 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(9, 303, 78); + break; + case 89: + case 121: + if ((active4 & 0x400000L) != 0L) + { + jjmatchedKind = 278; + jjmatchedPos = 9; + } + else if ((active4 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(9, 283, 78); + else if ((active5 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 382, 78); + else if ((active8 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(9, 529, 78); + else if ((active9 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(9, 631, 78); + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa10_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000000000000000L, active11, 0L); + default : + break; + } + return jjStartNfa_3(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa10_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_3(8, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 10; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x7400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x6000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa11_3(active0, 0x800000L, active1, 0x8000000000000000L, active2, 0L, active3, 0x40000000000L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0xc84881fff0000400L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active8 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(10, 558, 78); + return jjMoveStringLiteralDfa11_3(active0, 0x1000000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0x10000L, active8, 0x1100000000000000L, active9, 0x4000000000L, active10, 0L); + case 68: + case 100: + if ((active3 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(10, 216, 78); + else if ((active5 & 0x80L) != 0L) + return jjStartNfaWithStates_3(10, 327, 78); + else if ((active5 & 0x100L) != 0L) + return jjStartNfaWithStates_3(10, 328, 78); + else if ((active9 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 638, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x100000000L, active10, 0L); + case 69: + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(10, 39, 78); + else if ((active1 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(10, 88, 78); + else if ((active2 & 0x4L) != 0L) + return jjStartNfaWithStates_3(10, 130, 78); + else if ((active3 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(10, 207, 78); + else if ((active4 & 0x10L) != 0L) + return jjStartNfaWithStates_3(10, 260, 78); + else if ((active7 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(10, 487, 78); + else if ((active7 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 506, 78); + else if ((active9 & 0x400000L) != 0L) + return jjStartNfaWithStates_3(10, 598, 78); + else if ((active9 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(10, 602, 78); + else if ((active10 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 701, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0x1000000000L, active7, 0x1000000000008000L, active8, 0x2000000000000000L, active9, 0L, active10, 0x800080000f000L); + case 70: + case 102: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active6 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 442, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_3(10, 66, 78); + else if ((active6 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(10, 403, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L); + case 73: + case 105: + return jjMoveStringLiteralDfa11_3(active0, 0x10800000000L, active1, 0x200000001000L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xa00000000L, active10, 0L); + case 76: + case 108: + if ((active1 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(10, 94, 78); + else if ((active8 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(10, 536, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x400000000000010L, active2, 0L, active3, 0L, active4, 0x80L, active5, 0L, active6, 0L, active7, 0x100020000000000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa11_3(active0, 0x1000000000000000L, active1, 0x6000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x80010000000L, active8, 0L, active9, 0x10000000000000L, active10, 0L); + case 78: + case 110: + if ((active2 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(10, 159, 78); + else if ((active8 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(10, 532, 78); + else if ((active9 & 0x10000000000L) != 0L) + { + jjmatchedKind = 616; + jjmatchedPos = 10; + } + else if ((active9 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 624, 78); + else if ((active10 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 696, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x86100000L, active2, 0xc00000000180L, active3, 0L, active4, 0L, active5, 0x8L, active6, 0x8000400L, active7, 0L, active8, 0x602000000000000L, active9, 0x80000e0000000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x2000L, active9, 0x400000000L, active10, 0L); + case 80: + case 112: + if ((active9 & 0x80L) != 0L) + return jjStartNfaWithStates_3(10, 583, 78); + else if ((active10 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 694, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active1 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(10, 104, 78); + else if ((active8 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(10, 539, 78); + else if ((active9 & 0x1L) != 0L) + return jjStartNfaWithStates_3(10, 576, 78); + else if ((active9 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(10, 599, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0x800000021000L, active10, 0L); + case 83: + case 115: + if ((active1 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_3(10, 103, 78); + else if ((active2 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(10, 162, 78); + else if ((active4 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(10, 280, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x2001e0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active4 & 0x2000000L) != 0L) + { + jjmatchedKind = 281; + jjmatchedPos = 10; + } + else if ((active8 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 564, 78); + else if ((active9 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(10, 589, 78); + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0x2c0000000000000L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0x10000004000000L, active5, 0x800000000010L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000000L, active9, 0L, active10, 0L); + case 87: + case 119: + if ((active1 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 123, 78); + break; + case 88: + case 120: + return jjMoveStringLiteralDfa11_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x20L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 54, 78); + else if ((active3 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 247, 78); + else if ((active8 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(10, 565, 78); + break; + default : + break; + } + return jjStartNfa_3(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa11_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(9, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 11; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active7 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(11, 491, 78); + return jjMoveStringLiteralDfa12_3(active0, 0x1000000L, active1, 0x140000000180000L, active2, 0L, active3, 0L, active4, 0x10000004000000L, active5, 0L, active6, 0x400L, active7, 0x8000000L, active8, 0L, active9, 0x8008000000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0x1006200000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x40040000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x100000000L) != 0L) + return jjStartNfaWithStates_3(11, 608, 78); + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 69: + case 101: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 60, 78); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 119, 78); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 122, 78); + else if ((active1 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 125; + jjmatchedPos = 11; + } + else if ((active4 & 0x80L) != 0L) + return jjStartNfaWithStates_3(11, 263, 78); + else if ((active7 & 0x10000000L) != 0L) + return jjStartNfaWithStates_3(11, 476, 78); + else if ((active7 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 504, 78); + else if ((active8 & 0x800L) != 0L) + return jjStartNfaWithStates_3(11, 523, 78); + else if ((active9 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 628, 78); + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0x50000000000000f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0x4000000000000000L, active7, 0x20000000L, active8, 0L, active9, 0x20800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0x8L, active6, 0x1000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 121, 78); + else if ((active5 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(11, 367, 78); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000L, active10, 0L); + case 75: + case 107: + if ((active6 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(11, 411, 78); + else if ((active8 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 573, 78); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0x1fff0000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000400L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(11, 76, 78); + else if ((active4 & 0x800L) != 0L) + return jjStartNfaWithStates_3(11, 267, 78); + else if ((active8 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(11, 525, 78); + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0x8000202400000000L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0x80000000000L, active9, 0x800000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa12_3(active0, 0x800000000L, active1, 0L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x20000000000L, active8, 0x1000000000000000L, active9, 0x4000000000L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active2 & 0x1L) != 0L) + return jjStartNfaWithStates_3(11, 128, 78); + else if ((active4 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 316, 78); + else if ((active7 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 508, 78); + else if ((active8 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(11, 559, 78); + else if ((active8 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 567, 78); + else if ((active8 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 574, 78); + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x8900000000000000L, active9, 0L, active10, 0x20000000000000L); + case 83: + case 115: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe0000000000L, active10, 0L); + case 84: + case 116: + if ((active3 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(11, 234, 78); + else if ((active5 & 0x20L) != 0L) + return jjStartNfaWithStates_3(11, 325, 78); + else if ((active8 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 561, 78); + else if ((active10 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(11, 675, 78); + return jjMoveStringLiteralDfa12_3(active0, 0x10000800000L, active1, 0x100L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x400000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa12_3(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x200000000000000L, active9, 0x400000000L, active10, 0L); + case 89: + case 121: + if ((active10 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(11, 691, 78); + break; + default : + break; + } + return jjStartNfa_3(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa12_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(10, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 12; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa13_3(active0, 0x800000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4001fff0000000L, active9, 0xe0000000000L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x3400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active2 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(12, 161, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0xa00L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x400L) != 0L) + return jjStartNfaWithStates_3(12, 522, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000007000L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + if ((active9 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(12, 609, 78); + break; + case 71: + case 103: + if ((active1 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_3(12, 109, 78); + else if ((active4 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(12, 279, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000000L, active5, 0L, active6, 0L, active7, 0x20000008000L, active8, 0L, active9, 0x800000021000L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_3(12, 570, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa13_3(active0, 0x10000000000L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 76: + case 108: + if ((active9 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(12, 639, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x1000000080100000L, active2, 0L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0x400L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(12, 35, 78); + else if ((active2 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(12, 184, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x100000000000000L, active9, 0L, active10, 0x20000000000000L); + case 80: + case 112: + if ((active8 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(12, 563, 78); + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active9 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(12, 610, 78); + return jjMoveStringLiteralDfa13_3(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0xc000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x60800e0L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0x18L, active6, 0L, active7, 0L, active8, 0xa00000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa13_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x4800000000L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(12, 575, 78); + break; + default : + break; + } + return jjStartNfa_3(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa13_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(11, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 13; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0xe0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 124, 78); + else if ((active7 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(13, 477, 78); + else if ((active9 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 629, 78); + return jjMoveStringLiteralDfa14_3(active0, 0x800000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0x20000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 572, 78); + return jjMoveStringLiteralDfa14_3(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xf0000000L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x100000L) != 0L) + return jjStartNfaWithStates_3(13, 84, 78); + else if ((active6 & 0x200L) != 0L) + return jjStartNfaWithStates_3(13, 393, 78); + else if ((active6 & 0x400L) != 0L) + return jjStartNfaWithStates_3(13, 394, 78); + else if ((active8 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 569, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0x800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active4 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(13, 282, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x8L) != 0L) + return jjStartNfaWithStates_3(13, 323, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80700000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x1000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x2400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active3 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 248, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x20000000000L, active9, 0x4000000000L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa14_3(active0, 0x10000000000L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 80: + case 112: + if ((active4 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 308, 78); + break; + case 82: + case 114: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 83: + case 115: + if ((active7 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(13, 489, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(13, 446, 78); + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x38000L, active8, 0L, active9, 0x800000000L, active10, 0xf000L); + case 88: + case 120: + if ((active6 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(13, 420, 78); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa14_3(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_3(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa14_3(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(12, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 14; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0xa00f0000000L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active6 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(14, 410, 78); + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x20L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(14, 98, 78); + else if ((active1 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(14, 101, 78); + else if ((active4 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_3(14, 317, 78); + else if ((active9 & 0x800000000L) != 0L) + return jjStartNfaWithStates_3(14, 611, 78); + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x4080000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x14001c000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(14, 118, 78); + else if ((active7 & 0x8000000L) != 0L) + return jjStartNfaWithStates_3(14, 475, 78); + else if ((active9 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_3(14, 627, 78); + return jjMoveStringLiteralDfa15_3(active0, 0x800000L, active1, 0L, active2, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active7 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(14, 463, 78); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa15_3(active0, 0x1000000L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x80000L, active2, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x200000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(14, 40, 78); + else if ((active9 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(14, 588, 78); + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x40L, active2, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x8000000006000000L, active2, 0xc00000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2700000000L, active9, 0xc0000000000L, active10, 0L); + case 82: + case 114: + if ((active8 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(14, 554, 78); + else if ((active8 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_3(14, 571, 78); + break; + case 83: + case 115: + if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_3(14, 72, 78); + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x80L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x2000000L) != 0L) + return jjStartNfaWithStates_3(14, 409, 78); + else if ((active9 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(14, 614, 78); + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0x100000000000010L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0L, active2, 0x180L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active9 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(14, 593, 78); + else if ((active9 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(14, 623, 78); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa15_3(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + default : + break; + } + return jjStartNfa_3(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa15_3(long old0, long active0, long old1, long active1, long old2, long active2, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(13, old0, old1, old2, 0L, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 15; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x200000L) != 0L) + return jjStartNfaWithStates_3(15, 85, 78); + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x60L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0x400000000010L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_3(15, 23, 78); + break; + case 72: + case 104: + if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_3(15, 68, 78); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x4000004000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 15; + } + else if ((active2 & 0x400000000000L) != 0L) + { + jjmatchedKind = 174; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_3(active0, 0x1000000L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x80000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 82: + case 114: + if ((active1 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(15, 95, 78); + else if ((active8 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(15, 555, 78); + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x700000000L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x10000000L) != 0L) + { + jjmatchedKind = 540; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa16_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + default : + break; + } + return jjStartNfa_3(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa16_3(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(14, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 16; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(16, 102, 78); + return jjMoveStringLiteralDfa17_3(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 69: + case 101: + if ((active7 & 0x20000L) != 0L) + return jjStartNfaWithStates_3(16, 465, 78); + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0xf000L); + case 71: + case 103: + if ((active1 & 0x80000L) != 0L) + return jjStartNfaWithStates_3(16, 83, 78); + break; + case 72: + case 104: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0x8000000000000040L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + if ((active1 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_3(16, 126, 78); + break; + case 82: + case 114: + if ((active8 & 0x100000000L) != 0L) + { + jjmatchedKind = 544; + jjmatchedPos = 16; + } + else if ((active8 & 0x8000000000L) != 0L) + { + jjmatchedKind = 551; + jjmatchedPos = 16; + } + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0x100000000000020L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa17_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active5 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_3(16, 366, 78); + break; + case 89: + case 121: + if ((active8 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(16, 553, 78); + break; + default : + break; + } + return jjStartNfa_3(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa17_3(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(15, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0x8000000000000000L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_3(17, 70, 78); + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(17, 100, 78); + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_3(17, 549, 78); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa18_3(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 82: + case 114: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18e0000000L, active9, 0L, active10, 0x20000000000000L); + case 86: + case 118: + return jjMoveStringLiteralDfa18_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_3(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa18_3(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(16, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 18; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0x80L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x3000L); + case 68: + case 100: + if ((active8 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_3(18, 550, 78); + else if ((active8 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_3(18, 566, 78); + else if ((active8 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(18, 568, 78); + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x800000000L) != 0L) + { + jjmatchedKind = 547; + jjmatchedPos = 18; + } + else if ((active9 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_3(18, 617, 78); + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa19_3(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4000L); + case 79: + case 111: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0x100L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 84: + case 116: + return jjMoveStringLiteralDfa19_3(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0x4000L, active8, 0x10600000000L, active9, 0x40000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_3(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa19_3(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(17, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 19; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10e0000000L, active9, 0x80000000000L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_3(19, 71, 78); + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x5000L); + case 67: + case 99: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x1000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 68: + case 100: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x10L) != 0L) + return jjStartNfaWithStates_3(19, 324, 78); + break; + case 78: + case 110: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0x2000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0x20L, active2, 0x80L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0x20000000002000L); + case 82: + case 114: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0x8000000000000000L, active2, 0x100L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa20_3(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa20_3(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 89: + case 121: + if ((active7 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(19, 462, 78); + break; + default : + break; + } + return jjStartNfa_3(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa20_3(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(18, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); + return 20; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0x3000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0x80L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000L); + case 69: + case 101: + if ((active1 & 0x4000000L) != 0L) + return jjStartNfaWithStates_3(20, 90, 78); + else if ((active2 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_3(20, 175, 78); + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0x100L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_3(20, 69, 78); + break; + case 72: + case 104: + if ((active7 & 0x10000L) != 0L) + return jjStartNfaWithStates_3(20, 464, 78); + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x20000000L, active9, 0L, active10, 0x8000L); + case 77: + case 109: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x40000000L, active9, 0L, active10, 0x4000L); + case 78: + case 110: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0x100000000000000L, active2, 0L, active6, 0x800L, active7, 0L, active8, 0x80000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa21_3(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0x1000L); + case 89: + case 121: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_3(20, 24, 78); + break; + default : + break; + } + return jjStartNfa_3(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa21_3(long old0, long active0, long old1, long active1, long old2, long active2, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(19, old0, old1, old2, 0L, 0L, 0L, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 21; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 65: + case 97: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0x80000000000L, active10, 0x1000L); + case 67: + case 99: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_3(21, 618, 78); + break; + case 69: + case 101: + if ((active2 & 0x80L) != 0L) + return jjStartNfaWithStates_3(21, 135, 78); + else if ((active10 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(21, 653, 78); + else if ((active10 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(21, 654, 78); + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x8000L); + case 70: + case 102: + return jjMoveStringLiteralDfa22_3(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0x800L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0x2000L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x1020000000L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa22_3(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa22_3(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_3(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa22_3(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(20, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 22; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active6 & 0x2000L) != 0L) + return jjStartNfaWithStates_3(22, 397, 78); + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x200000000L, active9, 0L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x1000L); + case 77: + case 109: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000008000L); + case 78: + case 110: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa23_3(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0x10000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa23_3(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa23_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x20000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_3(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa23_3(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(21, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 23; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa24_3(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active10 & 0x8000L) != 0L) + return jjStartNfaWithStates_3(23, 655, 78); + break; + case 67: + case 99: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 75: + case 107: + if ((active9 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_3(23, 619, 78); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x20000000001000L); + case 82: + case 114: + if ((active8 & 0x20000000L) != 0L) + return jjStartNfaWithStates_3(23, 541, 78); + return jjMoveStringLiteralDfa24_3(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa24_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_3(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa24_3(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_3(22, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 24; + } + switch(curChar) + { + case 65: + case 97: + if ((active6 & 0x4000L) != 0L) + return jjStartNfaWithStates_3(24, 398, 78); + break; + case 68: + case 100: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active10, 0x20000000000000L); + case 69: + case 101: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa25_3(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 71: + case 103: + if ((active10 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(24, 652, 78); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa25_3(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0x1800L, active8, 0x400000000L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x10040000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa25_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_3(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa25_3(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_3(23, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 25; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa26_3(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa26_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x80000000L) != 0L) + return jjStartNfaWithStates_3(25, 543, 78); + break; + case 69: + case 101: + if ((active8 & 0x40000000L) != 0L) + return jjStartNfaWithStates_3(25, 542, 78); + else if ((active10 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_3(25, 693, 78); + break; + case 71: + case 103: + if ((active6 & 0x1000L) != 0L) + return jjStartNfaWithStates_3(25, 396, 78); + break; + case 72: + case 104: + if ((active8 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_3(25, 552, 78); + break; + case 78: + case 110: + if ((active6 & 0x800L) != 0L) + return jjStartNfaWithStates_3(25, 395, 78); + return jjMoveStringLiteralDfa26_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa26_3(active1, 0x8000000000000000L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa26_3(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_3(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa26_3(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_3(24, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 26; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x400000000L) != 0L) + return jjStartNfaWithStates_3(26, 546, 78); + break; + case 69: + case 101: + if ((active8 & 0x200000000L) != 0L) + return jjStartNfaWithStates_3(26, 545, 78); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa27_3(active1, 0x100000000000000L, active2, 0L, active8, 0L); + case 78: + case 110: + if ((active2 & 0x100L) != 0L) + return jjStartNfaWithStates_3(26, 136, 78); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa27_3(active1, 0L, active2, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa27_3(active1, 0x8000000000000000L, active2, 0L, active8, 0L); + default : + break; + } + return jjStartNfa_3(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa27_3(long old1, long active1, long old2, long active2, long old8, long active8) +{ + if (((active1 &= old1) | (active2 &= old2) | (active8 &= old8)) == 0L) + return jjStartNfa_3(25, 0L, old1, old2, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 27; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa28_3(active1, 0x8000000000000000L, active8, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa28_3(active1, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa28_3(active1, 0x100000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_3(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa28_3(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_3(26, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 28; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_3(28, 548, 78); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa29_3(active1, 0x100000000000000L, active8, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa29_3(active1, 0x8000000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_3(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa29_3(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_3(27, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 29; + } + switch(curChar) + { + case 85: + case 117: + return jjMoveStringLiteralDfa30_3(active1, 0x100000000000000L); + case 89: + case 121: + return jjMoveStringLiteralDfa30_3(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_3(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa30_3(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_3(28, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 30; + } + switch(curChar) + { + case 80: + case 112: + if ((active1 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_3(30, 120, 78); + return jjMoveStringLiteralDfa31_3(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_3(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa31_3(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_3(29, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_3(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 31; + } + switch(curChar) + { + case 69: + case 101: + if ((active1 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_3(31, 127, 78); + break; + default : + break; + } + return jjStartNfa_3(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveNfa_3(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 76; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + if ((0xfffffffbffffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + else if (curChar == 34) + { + if (kind > 724) + kind = 724; + } + break; + case 58: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + else if (curChar == 39) + { + if (kind > 725) + kind = 725; + } + if ((0xfc00f7faffffc9ffL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 76: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 715) + kind = 715; + jjCheckNAdd(52); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(51, 41); + break; + case 1: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + else if (curChar == 39) + jjCheckNAddStates(15, 17); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (curChar == 36) + jjCheckNAdd(27); + break; + case 31: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 32; + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (curChar == 36) + jjCheckNAdd(27); + break; + case 78: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x3ff001000000000L & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (curChar == 36) + jjCheckNAdd(27); + break; + case 77: + if (curChar == 32) + jjCheckNAddTwoStates(68, 69); + if (curChar == 32) + jjCheckNAddTwoStates(65, 66); + if (curChar == 32) + jjCheckNAddTwoStates(63, 64); + if (curChar == 32) + jjCheckNAddTwoStates(61, 62); + break; + case 80: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if (curChar == 36) + jjCheckNAdd(27); + break; + case 74: + if (curChar == 47) + { + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + } + else if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 72; + break; + case 0: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + else if (curChar == 47) + jjAddStates(70, 71); + else if (curChar == 39) + jjCheckNAddStates(72, 75); + else if (curChar == 46) + jjCheckNAddTwoStates(51, 52); + else if (curChar == 7) + { + if (kind > 786) + kind = 786; + } + else if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 11; + else if (curChar == 34) + jjCheckNAddStates(58, 60); + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 713) + kind = 713; + jjCheckNAddStates(76, 82); + } + else if (curChar == 36) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + break; + case 2: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(15, 17); + break; + case 3: + if (curChar == 39) + jjCheckNAddStates(15, 17); + break; + case 4: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 3; + break; + case 5: + if (curChar == 39 && kind > 719) + kind = 719; + break; + case 6: + if (curChar == 34) + jjCheckNAddStates(58, 60); + break; + case 7: + if ((0xfffffffbffffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + break; + case 9: + jjCheckNAddStates(58, 60); + break; + case 10: + if (curChar == 34 && kind > 724) + kind = 724; + break; + case 11: + if (curChar != 45) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + case 12: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + case 13: + if ((0x2400L & l) != 0L && kind > 772) + kind = 772; + break; + case 14: + if (curChar == 10 && kind > 772) + kind = 772; + break; + case 15: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 14; + break; + case 16: + if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 11; + break; + case 18: + case 20: + jjCheckNAddStates(83, 85); + break; + case 22: + if (curChar != 36) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 23: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 24: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + break; + case 25: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + break; + case 26: + if (curChar == 36) + jjCheckNAdd(27); + break; + case 27: + if (curChar != 36) + break; + if (kind > 782) + kind = 782; + jjCheckNAddTwoStates(27, 28); + break; + case 28: + if (curChar == 36) + jjCheckNAdd(29); + break; + case 29: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjCheckNAdd(29); + break; + case 32: + if (curChar == 34) + jjCheckNAddTwoStates(33, 35); + break; + case 33: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(86, 88); + break; + case 34: + if (curChar == 34) + jjCheckNAddStates(86, 88); + break; + case 35: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 34; + break; + case 36: + if (curChar == 34 && kind > 783) + kind = 783; + break; + case 37: + if (curChar == 7 && kind > 786) + kind = 786; + break; + case 38: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAddStates(76, 82); + break; + case 39: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAdd(39); + break; + case 40: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(40, 41); + break; + case 42: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(43); + break; + case 43: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 714) + kind = 714; + jjCheckNAdd(43); + break; + case 44: + if (curChar == 46) + jjCheckNAddTwoStates(45, 41); + break; + case 45: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(45, 41); + break; + case 46: + if (curChar != 46) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(47); + break; + case 47: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(47); + break; + case 48: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAddStates(89, 91); + break; + case 49: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(92, 95); + break; + case 50: + if (curChar == 46) + jjCheckNAddTwoStates(51, 52); + break; + case 51: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(51, 41); + break; + case 52: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(52); + break; + case 53: + if (curChar == 39) + jjCheckNAddStates(72, 75); + break; + case 54: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + break; + case 56: + jjCheckNAddStates(61, 63); + break; + case 57: + if (curChar == 39 && kind > 725) + kind = 725; + break; + case 59: + if (curChar == 39 && kind > 726) + kind = 726; + break; + case 61: + if (curChar == 32) + jjCheckNAddTwoStates(61, 62); + break; + case 63: + if (curChar == 32) + jjCheckNAddTwoStates(63, 64); + break; + case 65: + if (curChar == 32) + jjCheckNAddTwoStates(65, 66); + break; + case 68: + if (curChar == 32) + jjCheckNAddTwoStates(68, 69); + break; + case 71: + if (curChar == 47) + jjAddStates(70, 71); + break; + case 72: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 73; + break; + case 73: + if ((0xffff7fffffffffffL & l) != 0L && kind > 770) + kind = 770; + break; + case 75: + if (curChar != 47) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 9; + break; + case 58: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 56; + if ((0xffffff81ffffff81L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 1: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + break; + case 31: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + break; + case 78: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + break; + case 77: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 70; + else if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 67; + else if ((0x1000000010L & l) != 0L) + { + if (kind > 729) + kind = 729; + } + if ((0x10000000100000L & l) != 0L) + { + if (kind > 730) + kind = 730; + } + break; + case 80: + case 25: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + else if (curChar == 123) + jjAddStates(96, 103); + else if (curChar == 96) + jjCheckNAddStates(83, 85); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if ((0x20000000200000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 31; + else if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 2: + jjAddStates(15, 17); + break; + case 7: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + break; + case 8: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 9; + break; + case 9: + jjCheckNAddStates(58, 60); + break; + case 12: + if (kind > 772) + kind = 772; + jjAddStates(67, 69); + break; + case 17: + if (curChar == 96) + jjCheckNAddStates(83, 85); + break; + case 18: + if ((0xfffffffeefffffffL & l) != 0L) + jjCheckNAddStates(83, 85); + break; + case 19: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 20; + break; + case 20: + jjCheckNAddStates(83, 85); + break; + case 21: + if (curChar == 96 && kind > 779) + kind = 779; + break; + case 22: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 23: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 24: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + break; + case 27: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjAddStates(104, 105); + break; + case 29: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 29; + break; + case 30: + if ((0x20000000200000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 31; + break; + case 33: + jjAddStates(86, 88); + break; + case 41: + if ((0x2000000020L & l) != 0L) + jjAddStates(106, 107); + break; + case 54: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + break; + case 55: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 56: + jjCheckNAddStates(61, 63); + break; + case 60: + if (curChar == 123) + jjAddStates(96, 103); + break; + case 62: + if ((0x1000000010L & l) != 0L && kind > 729) + kind = 729; + break; + case 64: + if ((0x10000000100000L & l) != 0L && kind > 730) + kind = 730; + break; + case 66: + if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 67; + break; + case 67: + if ((0x8000000080000L & l) != 0L && kind > 731) + kind = 731; + break; + case 69: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 70; + break; + case 70: + if ((0x400000004000L & l) != 0L && kind > 732) + kind = 732; + break; + case 73: + if (kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + case 7: + case 9: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(58, 60); + break; + case 58: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(61, 63); + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 1: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 31: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 78: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 80: + case 25: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 0: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + break; + case 2: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(15, 17); + break; + case 12: + if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) + break; + if (kind > 772) + kind = 772; + jjAddStates(67, 69); + break; + case 18: + case 20: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(83, 85); + break; + case 22: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 23: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 781) + kind = 781; + jjCheckNAdd(23); + break; + case 24: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + break; + case 27: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjAddStates(104, 105); + break; + case 29: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 29; + break; + case 33: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(86, 88); + break; + case 54: + case 56: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(61, 63); + break; + case 73: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 76 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_5() +{ + return jjMoveNfa_5(1, 0); +} +private final int jjMoveNfa_5(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 2; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 0: + if (curChar == 47) + kind = 773; + break; + case 1: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 0; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + switch (pos) + { + case 0: + if ((active0 & 0x7ffe000000000L) != 0L || (active2 & 0xfffffffffffffff0L) != 0L || (active3 & 0xffffe0007fffffffL) != 0L || (active4 & 0x7ffffe1fffffffL) != 0L || (active5 & 0xffffffffffc00000L) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0x7fffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xfffffffffffffffL) != 0L || (active10 & 0xff27f7fffff00000L) != 0L || (active11 & 0x95L) != 0L) + { + jjmatchedKind = 780; + return 76; + } + if ((active11 & 0x10000400000000L) != 0L) + return 77; + if ((active9 & 0xf000000000000000L) != 0L || (active10 & 0xfffffL) != 0L || (active11 & 0x100L) != 0L) + { + jjmatchedKind = 780; + return 31; + } + if ((active11 & 0x20000000000000L) != 0L) + return 58; + if ((active10 & 0x80000000000L) != 0L) + { + jjmatchedKind = 780; + return 1; + } + if ((active11 & 0x20000000L) != 0L) + return 78; + if ((active11 & 0x1000000000000L) != 0L || (active12 & 0x9L) != 0L) + return 74; + if ((active0 & 0xfff8001ffffffff8L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfL) != 0L || (active3 & 0x1fff80000000L) != 0L || (active4 & 0xff800001e0000000L) != 0L || (active5 & 0x3fffffL) != 0L || (active7 & 0x8000000000000000L) != 0L || (active10 & 0xd8000000000000L) != 0L || (active11 & 0x20000000000006aL) != 0L) + return 76; + if ((active11 & 0x400000000000L) != 0L) + return 11; + if ((active11 & 0x40000000000000L) != 0L) + return 79; + return -1; + case 1: + if ((active12 & 0x9L) != 0L) + return 72; + if ((active0 & 0x40007fe000000L) != 0L || (active3 & 0xfc00006000000000L) != 0L || (active4 & 0x200000007ffffL) != 0L || (active5 & 0x78e6001f00000000L) != 0L || (active9 & 0x6000000000L) != 0L || (active10 & 0xa811000000000000L) != 0L || (active11 & 0x40L) != 0L) + return 76; + if ((active0 & 0xfff3fff801fffff0L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xffffffffffffffffL) != 0L || (active3 & 0x3ffff9f7fffffffL) != 0L || (active4 & 0xff7dffffdff80000L) != 0L || (active5 & 0x8719ffe0ffffffffL) != 0L || (active6 & 0xffffffffffffffffL) != 0L || (active7 & 0xffffffffffffffffL) != 0L || (active8 & 0xffffffffffffffffL) != 0L || (active9 & 0xffffff9fffffffffL) != 0L || (active10 & 0x57eeffffffffffffL) != 0L || (active11 & 0x1bfL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 780; + jjmatchedPos = 1; + } + return 76; + } + return -1; + case 2: + if ((active0 & 0x201004167370L) != 0L || (active2 & 0x1e00d000000f600L) != 0L || (active3 & 0x1000800780060L) != 0L || (active4 & 0xc1000005c0003f00L) != 0L || (active5 & 0x4800104001fc00L) != 0L || (active6 & 0x70000023f800087L) != 0L || (active7 & 0xe0000003c0000000L) != 0L || (active8 & 0xfffffffffffff000L) != 0L || (active9 & 0x80001L) != 0L || (active10 & 0x80000000000L) != 0L) + return 76; + if ((active0 & 0xfff3dfef79e98c80L) != 0L || (active1 & 0xffffffffffffffffL) != 0L || (active2 & 0xfe1ff2ffffff09ffL) != 0L || (active3 & 0xfbfeffd77f87ff9fL) != 0L || (active4 & 0x3e7dfffa1fff40ffL) != 0L || (active5 & 0xf795ffeebffe03ffL) != 0L || (active6 & 0xf8fffffdc07fff78L) != 0L || (active7 & 0x1ffffffc3fffffffL) != 0L || (active8 & 0xfffL) != 0L || (active9 & 0xffffffdffff7fffeL) != 0L || (active10 & 0xfffef7ffffffffffL) != 0L || (active11 & 0x1ffL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 780; + jjmatchedPos = 2; + } + return 76; + } + return -1; + case 3: + if ((active0 & 0x99c29fef79e9ece0L) != 0L || (active1 & 0xfff7cfffffffdc01L) != 0L || (active2 & 0xff9ae2fe1fffe80fL) != 0L || (active3 & 0xfbf87f9763f7ffd3L) != 0L || (active4 & 0xbe7d389b80075effL) != 0L || (active5 & 0xf605f86c3f37bbffL) != 0L || (active6 & 0xfe87f7fcff4fff06L) != 0L || (active7 & 0x9febfffdbf7fffffL) != 0L || (active8 & 0xffffffffffffefa6L) != 0L || (active9 & 0xf63fffd00ff7fffdL) != 0L || (active10 & 0xfefe061c3ffd07ffL) != 0L || (active11 & 0xf9L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 780; + jjmatchedPos = 3; + } + return 76; + } + if ((active0 & 0x6631400000000000L) != 0L || (active1 & 0x83000000023feL) != 0L || (active2 & 0x51001e00005f0L) != 0L || (active3 & 0x680401c00000cL) != 0L || (active4 & 0xc7601ff82000L) != 0L || (active5 & 0x190078280c80000L) != 0L || (active6 & 0x78080100300078L) != 0L || (active7 & 0x4014000200800000L) != 0L || (active8 & 0x59L) != 0L || (active9 & 0x9c0000ff0000002L) != 0L || (active10 & 0x100f1e3c002f800L) != 0L || (active11 & 0x106L) != 0L) + return 76; + if ((active2 & 0x40000000000000L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 780; + jjmatchedPos = 3; + } + return 80; + } + return -1; + case 4: + if ((active2 & 0x40000000000000L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 780; + jjmatchedPos = 4; + } + return 80; + } + if ((active0 & 0xd9e29e2f780120e0L) != 0L || (active1 & 0xfff3affffffe9bfcL) != 0L || (active2 & 0xd592e2ffd3ffe9a7L) != 0L || (active3 & 0xfbd86017637413dbL) != 0L || (active4 & 0x8020aac99fc75ef1L) != 0L || (active5 & 0xc605fb2c2711bbfbL) != 0L || (active6 & 0xfe83d7dcbf4fff74L) != 0L || (active7 & 0x1febf0ddbf1ffeffL) != 0L || (active8 & 0xffffffffffffeea6L) != 0L || (active9 & 0xf6bdffdf88f7f7e1L) != 0L || (active10 & 0xf5de02da3f80f2fcL) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 780; + jjmatchedPos = 4; + } + return 76; + } + if ((active0 & 0x1c001e8cc00L) != 0L || (active1 & 0x4400000014401L) != 0L || (active2 & 0x2a0800000c000008L) != 0L || (active3 & 0x241f800083ec00L) != 0L || (active4 & 0x3e5d10120000000eL) != 0L || (active5 & 0x3000044018a60004L) != 0L || (active6 & 0x24202040000002L) != 0L || (active7 & 0x80000f2000600100L) != 0L || (active8 & 0x100L) != 0L || (active9 & 0x200000700081cL) != 0L || (active10 & 0xa202404007d0503L) != 0L || (active11 & 0xc0L) != 0L) + return 76; + return -1; + case 5: + if ((active0 & 0xd9c2878e79c02040L) != 0L || (active1 & 0xfff1afffe67e9bfcL) != 0L || (active2 & 0x192e07fd20fc9a1L) != 0L || (active3 & 0xf9c84d072364834bL) != 0L || (active4 & 0xbc38a2c99fc65ed1L) != 0L || (active5 & 0x6000d12c2710a3b9L) != 0L || (active6 & 0xfe82d7dcaf4dff70L) != 0L || (active7 & 0x19e30e0dbd000effL) != 0L || (active8 & 0xffffffffffffee22L) != 0L || (active9 & 0xf2bdffdf8e17b6d1L) != 0L || (active10 & 0xf7ee028a3fc0f038L) != 0L || (active11 & 0x39L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 780; + jjmatchedPos = 5; + } + return 76; + } + if ((active2 & 0x40000000000000L) != 0L) + { + if (jjmatchedPos != 5) + { + jjmatchedKind = 780; + jjmatchedPos = 5; + } + return 80; + } + if ((active0 & 0x201821000100a0L) != 0L || (active1 & 0x2000019800000L) != 0L || (active2 & 0xd400028001f02006L) != 0L || (active3 & 0x210301040101090L) != 0L || (active4 & 0x80000010020L) != 0L || (active5 & 0x86052a0000051842L) != 0L || (active6 & 0x1000010020004L) != 0L || (active7 & 0x608f0d0021ff000L) != 0L || (active8 & 0x84L) != 0L || (active9 & 0x400000000e04120L) != 0L || (active10 & 0x100050002002c4L) != 0L) + return 76; + return -1; + case 6: + if ((active2 & 0x40000000000000L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 780; + jjmatchedPos = 6; + } + return 80; + } + if ((active0 & 0xd982840000000000L) != 0L || (active1 & 0xffe0080700420000L) != 0L || (active2 & 0x2e0001063c001L) != 0L || (active3 & 0x8800010100600249L) != 0L || (active4 & 0xc20228000024201L) != 0L || (active5 & 0x400100024001000L) != 0L || (active6 & 0x80021204af448020L) != 0L || (active7 & 0x180180043c0806a0L) != 0L || (active8 & 0x40002L) != 0L || (active9 & 0x103c001000000000L) != 0L || (active10 & 0x400402803c800038L) != 0L || (active11 & 0x30L) != 0L) + return 76; + if ((active0 & 0x40038e79c02040L) != 0L || (active1 & 0x11a7f8f73c9bfcL) != 0L || (active2 & 0x8190007fc20c09a4L) != 0L || (active3 & 0x71c84c0623048102L) != 0L || (active4 & 0xb01880499fc41cd0L) != 0L || (active5 & 0x6000c12c0310a3b9L) != 0L || (active6 & 0x7e80c5d800097f50L) != 0L || (active7 & 0x5e20e898107c85fL) != 0L || (active8 & 0xfffffffffffbee20L) != 0L || (active9 & 0xe281ffcf8ed7b6d1L) != 0L || (active10 & 0xb7fa000a0340f000L) != 0L || (active11 & 0x9L) != 0L) + { + if (jjmatchedPos != 6) + { + jjmatchedKind = 780; + jjmatchedPos = 6; + } + return 76; + } + return -1; + case 7: + if ((active0 & 0x1040038e79c00000L) != 0L || (active1 & 0xffd1a1fef73c1bfcL) != 0L || (active2 & 0x8180c01782040985L) != 0L || (active3 & 0x71c0440203048002L) != 0L || (active4 & 0x301880409fc40c91L) != 0L || (active5 & 0x4000c02c010003b8L) != 0L || (active6 & 0x7e80c1800e097f40L) != 0L || (active7 & 0x15600e89b807c041L) != 0L || (active8 & 0xfff2ffffff13a000L) != 0L || (active9 & 0xe0b9ff4f8ed3b6d1L) != 0L || (active10 & 0xa7f800082200f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 7) + { + jjmatchedKind = 780; + jjmatchedPos = 7; + } + return 76; + } + if ((active0 & 0x100000000002040L) != 0L || (active1 & 0x60000008000L) != 0L || (active2 & 0x100068400a0020L) != 0L || (active3 & 0x8080420000100L) != 0L || (active4 & 0x8000000900001040L) != 0L || (active5 & 0x200001000210a001L) != 0L || (active6 & 0x45800000010L) != 0L || (active7 & 0x8200000100081eL) != 0L || (active8 & 0xd000000e84e20L) != 0L || (active9 & 0x200008000040000L) != 0L || (active10 & 0x1002000201400000L) != 0L || (active11 & 0x1L) != 0L) + return 76; + if ((active2 & 0x40000000000000L) != 0L) + return 80; + return -1; + case 8: + if ((active0 & 0x1040018869800000L) != 0L || (active1 & 0xffc121fe07001804L) != 0L || (active2 & 0x100c01782040985L) != 0L || (active3 & 0x100040001008000L) != 0L || (active4 & 0x300080409fc00090L) != 0L || (active5 & 0x4000c000010003b8L) != 0L || (active6 & 0x660040100e080040L) != 0L || (active7 & 0x15000e813803c041L) != 0L || (active8 & 0xfffacffffb13ac00L) != 0L || (active9 & 0xc0b90f4c06c0b2c1L) != 0L || (active10 & 0x23e800082000f000L) != 0L || (active11 & 0x8L) != 0L) + { + if (jjmatchedPos != 8) + { + jjmatchedKind = 780; + jjmatchedPos = 8; + } + return 76; + } + if ((active0 & 0x20610400000L) != 0L || (active1 & 0x108000f03c03f8L) != 0L || (active2 & 0x8080000000000000L) != 0L || (active3 & 0x70c0400202040002L) != 0L || (active4 & 0x18000000040c01L) != 0L || (active5 & 0x2c00000000L) != 0L || (active6 & 0x1880818000017f00L) != 0L || (active7 & 0x60000880040000L) != 0L || (active8 & 0x300004000000L) != 0L || (active9 & 0x2000f00388130410L) != 0L || (active10 & 0x8410000002000000L) != 0L) + return 76; + return -1; + case 9: + if ((active0 & 0x468000000L) != 0L || (active1 & 0x100fe00000a00L) != 0L || (active2 & 0x1102040800L) != 0L || (active4 & 0x804098c00000L) != 0L || (active5 & 0x4000000801000200L) != 0L || (active6 & 0x2200400000000040L) != 0L || (active7 & 0x40100000041L) != 0L || (active8 & 0x2038000L) != 0L || (active9 & 0x80200002008240L) != 0L || (active10 & 0x280000020000000L) != 0L || (active11 & 0x8L) != 0L) + return 76; + if ((active0 & 0x1040018801800000L) != 0L || (active1 & 0xffc02100c73811f4L) != 0L || (active2 & 0x100c00680000185L) != 0L || (active3 & 0x180040001008000L) != 0L || (active4 & 0x3010000007000890L) != 0L || (active5 & 0xc000000001b8L) != 0L || (active6 & 0x440000100e087e00L) != 0L || (active7 & 0x15000a803803c000L) != 0L || (active8 & 0xfffacffff9102c00L) != 0L || (active9 & 0xc0398f4f04c23081L) != 0L || (active10 & 0x216800080000f000L) != 0L) + { + if (jjmatchedPos != 9) + { + jjmatchedKind = 780; + jjmatchedPos = 9; + } + return 76; + } + return -1; + case 10: + if ((active0 & 0x1000010801800000L) != 0L || (active1 & 0xf7c02074863811f0L) != 0L || (active2 & 0x100c00200000181L) != 0L || (active3 & 0x100040000000000L) != 0L || (active4 & 0x3010000000800880L) != 0L || (active5 & 0xc00000000038L) != 0L || (active6 & 0x400000100e007e00L) != 0L || (active7 & 0x11000a003803c000L) != 0L || (active8 & 0xffca8ffff0002c00L) != 0L || (active9 & 0x8038804f00021000L) != 0L || (active10 & 0x2800080000f000L) != 0L) + { + if (jjmatchedPos != 10) + { + jjmatchedKind = 780; + jjmatchedPos = 10; + } + return 76; + } + if ((active0 & 0x40008000000000L) != 0L || (active1 & 0x800018041000004L) != 0L || (active2 & 0x480000004L) != 0L || (active3 & 0x80000001008000L) != 0L || (active4 & 0x7000010L) != 0L || (active5 & 0x180L) != 0L || (active6 & 0x400000000080000L) != 0L || (active7 & 0x400008000000000L) != 0L || (active8 & 0x30400009100000L) != 0L || (active9 & 0x40010f0004c02081L) != 0L || (active10 & 0x2140000000000000L) != 0L) + return 76; + return -1; + case 11: + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x6680000000001000L) != 0L || (active2 & 0x1L) != 0L || (active3 & 0x40000000000L) != 0L || (active4 & 0x1000000000000880L) != 0L || (active5 & 0x800000000020L) != 0L || (active6 & 0x8000000L) != 0L || (active7 & 0x1100080010000000L) != 0L || (active8 & 0x6082800000002800L) != 0L || (active9 & 0x10000100000000L) != 0L || (active10 & 0x8000800000000L) != 0L) + return 76; + if ((active0 & 0x10801800000L) != 0L || (active1 & 0x91402074863801f0L) != 0L || (active2 & 0x100c00200000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004800000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x9f480ffff0000400L) != 0L || (active9 & 0x80288e4e00021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 11) + { + jjmatchedKind = 780; + jjmatchedPos = 11; + } + return 76; + } + return -1; + case 12: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xd1400074863801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x2010000004000000L) != 0L || (active5 & 0x400000000018L) != 0L || (active6 & 0x4000001006007e00L) != 0L || (active7 & 0x2002803c000L) != 0L || (active8 & 0x1b400ffff0000000L) != 0L || (active9 & 0x288e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 12; + return 76; + } + if ((active0 & 0x800000000L) != 0L || (active1 & 0x200000000000L) != 0L || (active2 & 0x100000200000000L) != 0L || (active4 & 0x800000L) != 0L || (active8 & 0x8408000000000400L) != 0L || (active9 & 0x8000000600000000L) != 0L) + return 76; + return -1; + case 13: + if ((active0 & 0x10001800000L) != 0L || (active1 & 0xc1400074862801f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x6007800L) != 0L || (active7 & 0x803c000L) != 0L || (active8 & 0x9400ffff0000000L) != 0L || (active9 & 0x88e4800021000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 13; + return 76; + } + if ((active1 & 0x1000000000100000L) != 0L || (active3 & 0x100000000000000L) != 0L || (active4 & 0x10000004000000L) != 0L || (active5 & 0x8L) != 0L || (active6 & 0x4000001000000600L) != 0L || (active7 & 0x20020000000L) != 0L || (active8 & 0x1200000000000000L) != 0L || (active9 & 0x20000000000000L) != 0L) + return 76; + return -1; + case 14: + if ((active0 & 0x1800000L) != 0L || (active1 & 0xc1000050862800f0L) != 0L || (active2 & 0xc00000000180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x1400bfff0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 14; + return 76; + } + if ((active0 & 0x10000000000L) != 0L || (active1 & 0x40002400000100L) != 0L || (active4 & 0x2000000000000000L) != 0L || (active6 & 0x6000000L) != 0L || (active7 & 0x8008000L) != 0L || (active8 & 0x800040000000000L) != 0L || (active9 & 0x8804800021000L) != 0L) + return 76; + return -1; + case 15: + if ((active0 & 0x800000L) != 0L || (active1 & 0x86200010L) != 0L || (active2 & 0xc00000000000L) != 0L || (active8 & 0x800f0000000L) != 0L) + return 76; + if ((active0 & 0x1000000L) != 0L || (active1 & 0xc1000050000800e0L) != 0L || (active2 & 0x180L) != 0L || (active5 & 0x400000000010L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x34000L) != 0L || (active8 & 0x14003ff00000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 15) + { + jjmatchedKind = 780; + jjmatchedPos = 15; + } + return 76; + } + return -1; + case 16: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000010040000e0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x1400078e0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 16) + { + jjmatchedKind = 780; + jjmatchedPos = 16; + } + return 76; + } + if ((active1 & 0x4000004000080000L) != 0L || (active5 & 0x400000000000L) != 0L || (active7 & 0x20000L) != 0L || (active8 & 0x38700000000L) != 0L) + return 76; + return -1; + case 17: + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x140015ee0000000L) != 0L || (active9 & 0xe0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 17; + return 76; + } + if ((active1 & 0x1000000040L) != 0L || (active8 & 0x2000000000L) != 0L) + return 76; + return -1; + case 18: + if ((active8 & 0x140005800000000L) != 0L || (active9 & 0x20000000000L) != 0L) + return 76; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x81000000040000a0L) != 0L || (active2 & 0x800000000180L) != 0L || (active5 & 0x10L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x14000L) != 0L || (active8 & 0x106e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + if (jjmatchedPos != 18) + { + jjmatchedKind = 780; + jjmatchedPos = 18; + } + return 76; + } + return -1; + case 19: + if ((active1 & 0x80L) != 0L || (active5 & 0x10L) != 0L || (active7 & 0x4000L) != 0L) + return 76; + if ((active0 & 0x1000000L) != 0L || (active1 & 0x8100000004000020L) != 0L || (active2 & 0x800000000180L) != 0L || (active6 & 0x7800L) != 0L || (active7 & 0x10000L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 19; + return 76; + } + return -1; + case 20: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x180L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0xc0000000000L) != 0L || (active10 & 0x2000000000f000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 20; + return 76; + } + if ((active0 & 0x1000000L) != 0L || (active1 & 0x4000020L) != 0L || (active2 & 0x800000000000L) != 0L || (active7 & 0x10000L) != 0L) + return 76; + return -1; + case 21: + if ((active2 & 0x80L) != 0L || (active9 & 0x40000000000L) != 0L || (active10 & 0x6000L) != 0L) + return 76; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x7800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 21; + return 76; + } + return -1; + case 22: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116e0000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x20000000009000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 22; + return 76; + } + if ((active6 & 0x2000L) != 0L) + return 76; + return -1; + case 23: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x5800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000001000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 23; + return 76; + } + if ((active8 & 0x20000000L) != 0L || (active9 & 0x80000000000L) != 0L || (active10 & 0x8000L) != 0L) + return 76; + return -1; + case 24: + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active6 & 0x1800L) != 0L || (active8 & 0x116c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 24; + return 76; + } + if ((active6 & 0x4000L) != 0L || (active10 & 0x1000L) != 0L) + return 76; + return -1; + case 25: + if ((active6 & 0x1800L) != 0L || (active8 & 0x100c0000000L) != 0L || (active10 & 0x20000000000000L) != 0L) + return 76; + if ((active1 & 0x8100000000000000L) != 0L || (active2 & 0x100L) != 0L || (active8 & 0x1600000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 25; + return 76; + } + return -1; + case 26: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 26; + return 76; + } + if ((active2 & 0x100L) != 0L || (active8 & 0x600000000L) != 0L) + return 76; + return -1; + case 27: + if ((active1 & 0x8100000000000000L) != 0L || (active8 & 0x1000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 27; + return 76; + } + return -1; + case 28: + if ((active8 & 0x1000000000L) != 0L) + return 76; + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 28; + return 76; + } + return -1; + case 29: + if ((active1 & 0x8100000000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 29; + return 76; + } + return -1; + case 30: + if ((active1 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 780; + jjmatchedPos = 30; + return 76; + } + if ((active1 & 0x100000000000000L) != 0L) + return 76; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_4(int pos, long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12), pos + 1); +} +private final int jjStartNfaWithStates_4(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_4(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_4() +{ + switch(curChar) + { + case 33: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000L, 0x0L); + case 34: + return jjStartNfaWithStates_4(0, 758, 79); + case 36: + return jjStartNfaWithStates_4(0, 761, 76); + case 37: + return jjStopAtPos(0, 753); + case 39: + return jjStartNfaWithStates_4(0, 757, 58); + case 40: + return jjStopAtPos(0, 727); + case 41: + return jjStopAtPos(0, 728); + case 42: + jjmatchedKind = 751; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L); + case 43: + return jjStopAtPos(0, 749); + case 44: + return jjStopAtPos(0, 739); + case 45: + return jjStartNfaWithStates_4(0, 750, 11); + case 46: + jjmatchedKind = 738; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x10000000000000L, 0x0L); + case 47: + jjmatchedKind = 752; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x9L); + case 58: + jjmatchedKind = 744; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L); + case 59: + return jjStopAtPos(0, 737); + case 60: + jjmatchedKind = 742; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xa0000000000L, 0x0L); + case 61: + jjmatchedKind = 740; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000L, 0x0L); + case 62: + jjmatchedKind = 741; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x40000000000L, 0x0L); + case 63: + return jjStopAtPos(0, 743); + case 91: + return jjStopAtPos(0, 735); + case 93: + return jjStopAtPos(0, 736); + case 94: + return jjStopAtPos(0, 760); + case 65: + case 97: + jjmatchedKind = 3; + return jjMoveStringLiteralDfa1_4(0x1ffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x18000000000000L, 0x40L, 0x0L); + case 66: + case 98: + return jjMoveStringLiteralDfa1_4(0x7ffe000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L, 0x0L); + case 67: + case 99: + jjmatchedKind = 51; + return jjMoveStringLiteralDfa1_4(0xfff0000000000000L, 0xffffffffffffffffL, 0xfL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xc0000000000000L, 0x28L, 0x0L); + case 68: + case 100: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0xfffffffffff0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x100000000000000L, 0x0L, 0x0L); + case 69: + case 101: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0xffff000000000000L, 0x3ffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000000L, 0x0L, 0x0L); + case 70: + case 102: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x7ffffc00L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 71: + case 103: + jjmatchedKind = 223; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x1fff00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 72: + case 104: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x7e00000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 73: + case 105: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0xfff8000000000000L, 0x7ffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2801000000000000L, 0x0L, 0x0L); + case 74: + case 106: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x1ff80000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 75: + case 107: + jjmatchedKind = 285; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x1c0000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2L, 0x0L); + case 76: + case 108: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffe00000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000000L, 0x0L, 0x0L); + case 77: + case 109: + jjmatchedKind = 311; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0xff00000000000000L, 0x3fffffL, 0x0L, 0x8000000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 78: + case 110: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1fffffc00000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x8000000000000000L, 0x0L, 0x0L); + case 79: + case 111: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xffffe00000000000L, 0x7fL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 80: + case 112: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x1ffffffffff80L, 0x0L, 0x0L, 0x0L, 0x1000000000000000L, 0x1L, 0x0L); + case 81: + case 113: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2000000000000L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80L, 0x0L); + case 82: + case 114: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffc000000000000L, 0x7ffffffffL, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L); + case 83: + case 115: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x7ffffff800000000L, 0xffffffffffffffffL, 0xffffffL, 0x800000000000L, 0x14L, 0x0L); + case 84: + case 116: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xfffffffff000000L, 0x2000000000000L, 0x0L, 0x0L); + case 85: + case 117: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0xf000000000000000L, 0xfffffL, 0x100L, 0x0L); + case 86: + case 118: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x20000007ff00000L, 0x0L, 0x0L); + case 87: + case 119: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x2007ff80000000L, 0x0L, 0x0L); + case 88: + case 120: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x80000000000L, 0x0L, 0x0L); + case 89: + case 121: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x300000000000L, 0x0L, 0x0L); + case 90: + case 122: + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x400000000000L, 0x0L, 0x0L); + case 123: + return jjStartNfaWithStates_4(0, 733, 78); + case 124: + jjmatchedKind = 759; + return jjMoveStringLiteralDfa1_4(0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x0L, 0x4000000000000L, 0x0L); + case 125: + return jjStopAtPos(0, 734); + default : + return jjMoveNfa_4(0, 0); + } +} +private final int jjMoveStringLiteralDfa1_4(long active0, long active1, long active2, long active3, long active4, long active5, long active6, long active7, long active8, long active9, long active10, long active11, long active12) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 1; + } + switch(curChar) + { + case 42: + if ((active12 & 0x8L) != 0L) + { + jjmatchedKind = 771; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0x1L); + case 46: + if ((active11 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 756); + break; + case 47: + if ((active12 & 0x2L) != 0L) + return jjStopAtPos(1, 769); + break; + case 58: + if ((active11 & 0x400000000000000L) != 0L) + return jjStopAtPos(1, 762); + break; + case 61: + if ((active11 & 0x20000000000L) != 0L) + return jjStopAtPos(1, 745); + else if ((active11 & 0x40000000000L) != 0L) + return jjStopAtPos(1, 746); + else if ((active11 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 748); + break; + case 62: + if ((active11 & 0x80000000000L) != 0L) + return jjStopAtPos(1, 747); + else if ((active11 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 755); + break; + case 65: + case 97: + return jjMoveStringLiteralDfa2_4(active0, 0x1ff0000000000000L, active1, 0L, active2, 0x10000000007f0L, active3, 0x200000000400L, active4, 0xff0000fe00080000L, active5, 0x7c00000L, active6, 0xc0000007fff80L, active7, 0x800000000L, active8, 0L, active9, 0x7000000L, active10, 0x13c400000ff00000L, active11, 0x1L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa2_4(active0, 0x70L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa2_4(active0, 0x80L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1c00018000000L, active6, 0L, active7, 0x1ff000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x4L, active12, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa2_4(active0, 0x700L, active1, 0L, active2, 0L, active3, 0x8000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa2_4(active0, 0xe00007e000000000L, active1, 0L, active2, 0x3fffff800L, active3, 0xf00000800L, active4, 0x1f01c0000000L, active5, 0xe000007fL, active6, 0xfff000003f800000L, active7, 0x7fffe000001fffffL, active8, 0L, active9, 0x1000000008000000L, active10, 0x2b000b0000000L, active11, 0x10L, active12, 0L); + case 70: + case 102: + if ((active5 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 369; + jjmatchedPos = 1; + } + else if ((active10 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(1, 688, 76); + return jjMoveStringLiteralDfa2_4(active0, 0x800L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x4000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000000000000L, active11, 0L, active12, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x10000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0x7ffL, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1L, active9, 0x10000000L, active10, 0x700000000L, active11, 0L, active12, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa2_4(active0, 0x380000000000L, active1, 0L, active2, 0x7c00000000L, active3, 0x40000000f000L, active4, 0x1e00000000000L, active5, 0x3f80L, active6, 0x40000000L, active7, 0x8000000000200000L, active8, 0xeL, active9, 0x1fe0000000L, active10, 0xf840000000L, active11, 0x2L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa2_4(active0, 0x40000001f000L, active1, 0x7800L, active2, 0x6000000000000L, active3, 0x20001000030000L, active4, 0L, active5, 0x8000000000000L, active6, 0x380000000L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0x8000000000000L, active3, 0x3c0000000000000L, active4, 0L, active5, 0x10000000000000L, active6, 0L, active7, 0L, active8, 0x20L, active9, 0L, active10, 0x80000000000L, active11, 0L, active12, 0L); + case 78: + case 110: + if ((active3 & 0x400000000000000L) != 0L) + { + jjmatchedKind = 250; + jjmatchedPos = 1; + } + else if ((active4 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(1, 305, 76); + else if ((active5 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 373; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0x60000L, active1, 0L, active2, 0x1f0000000000000L, active3, 0xf800000000000000L, active4, 0x7fffL, active5, 0xc0000000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe000000000000000L, active10, 0x2c0000000000007fL, active11, 0L, active12, 0L); + case 79: + case 111: + if ((active3 & 0x2000000000L) != 0L) + { + jjmatchedKind = 229; + jjmatchedPos = 1; + } + else if ((active5 & 0x100000000L) != 0L) + { + jjmatchedKind = 352; + jjmatchedPos = 1; + } + else if ((active9 & 0x2000000000L) != 0L) + { + jjmatchedKind = 613; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0x1800000000000L, active1, 0x1ffffffff8000L, active2, 0xf8000000000L, active3, 0x7804000fc0000L, active4, 0x7c000000100000L, active5, 0x1e000fc000L, active6, 0x3c00000000L, active7, 0x3ff800000L, active8, 0xc0L, active9, 0x4000000000L, active10, 0xc000410000000000L, active11, 0x28L, active12, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa2_4(active0, 0x80000L, active1, 0L, active2, 0x200000000000000L, active3, 0L, active4, 0L, active5, 0x700000000000000L, active6, 0L, active7, 0L, active8, 0xf00L, active9, 0L, active10, 0x380L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0x400000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xfffffffffffff000L, active9, 0x3L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active5 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 379; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0x2000001f00000L, active1, 0x6000000000000L, active2, 0x800100000000000L, active3, 0x1f800f000000L, active4, 0L, active5, 0x7000000000000000L, active6, 0xffc000000000L, active7, 0L, active8, 0L, active9, 0x3ffff8000000000L, active10, 0x20060000000000L, active11, 0L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x2000000L) != 0L) + { + jjmatchedKind = 25; + jjmatchedPos = 1; + } + else if ((active4 & 0x8000L) != 0L) + { + jjmatchedKind = 271; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0x7c000000L, active1, 0L, active2, 0x1000000000000000L, active3, 0L, active4, 0x1fe70000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x1fc00L, active11, 0x40L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x80000000L) != 0L) + { + jjmatchedKind = 31; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_4(active0, 0x700000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000006000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xffcL, active10, 0x100000000e0000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa2_4(active0, 0x800000000L, active1, 0xfff8000000000000L, active2, 0x7L, active3, 0x70000000L, active4, 0L, active5, 0x1f8000300000L, active6, 0x3000000000007L, active7, 0x400000000L, active8, 0L, active9, 0x4000000000ff000L, active10, 0L, active11, 0x180L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa2_4(active0, 0x1000000000L, active1, 0L, active2, 0x2000000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x78L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0xc000000000000000L, active3, 0x3ffL, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(1, 50, 76); + return jjMoveStringLiteralDfa2_4(active0, 0L, active1, 0L, active2, 0xe00000000008L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800000000f00000L, active10, 0L, active11, 0L, active12, 0L); + case 124: + if ((active11 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 754); + break; + default : + break; + } + return jjStartNfa_4(0, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa2_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_4(0, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); + return 2; + } + switch(curChar) + { + case 43: + if ((active12 & 0x1L) != 0L) + return jjStopAtPos(2, 768); + break; + case 65: + case 97: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_4(2, 8, 76); + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0x9bffL, active2, 0x400000800L, active3, 0x18003000000L, active4, 0x30000000000L, active5, 0x1L, active6, 0x72000180000000L, active7, 0x203000000000L, active8, 0x120L, active9, 0x1ff800000003cL, active10, 0x320000000400L, active11, 0x4L, active12, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0x8000000010000L, active2, 0L, active3, 0L, active4, 0x200200000000L, active5, 0L, active6, 0x1000000000000L, active7, 0L, active8, 0L, active9, 0x200000000703f000L, active10, 0L, active11, 0L, active12, 0L); + case 67: + case 99: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(2, 26, 76); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0xd01100000000e008L, active3, 0x3800000000000003L, active4, 0x3c000000000000L, active5, 0x400000000080L, active6, 0x80000000000000L, active7, 0x3c00000000000L, active8, 0L, active9, 0xc000000000040000L, active10, 0x4c4000000000000L, active11, 0L, active12, 0L); + case 68: + case 100: + if ((active0 & 0x200L) != 0L) + return jjStartNfaWithStates_4(2, 9, 76); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(2, 17, 76); + else if ((active2 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 181; + jjmatchedPos = 2; + } + else if ((active5 & 0x4000L) != 0L) + { + jjmatchedKind = 334; + jjmatchedPos = 2; + } + else if ((active5 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(2, 371, 76); + else if ((active6 & 0x80L) != 0L) + return jjStartNfaWithStates_4(2, 391, 76); + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0x1c0000000000000L, active3, 0x4000000000000000L, active4, 0L, active5, 0x7000000000018000L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x800000800000081L, active11, 0L, active12, 0L); + case 69: + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(2, 20, 76); + else if ((active5 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(2, 374, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x2000008000000L, active1, 0x2000000000400L, active2, 0x2002000000000000L, active3, 0x840000400000cL, active4, 0L, active5, 0x100000000000000L, active6, 0xfc000000078L, active7, 0x4000000000000L, active8, 0xe00L, active9, 0x2000030000000L, active10, 0x7c000f800L, active11, 0x80L, active12, 0L); + case 70: + case 102: + if ((active6 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 440; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x2000000000L, active1, 0L, active2, 0x7f0000L, active3, 0L, active4, 0x40000000000L, active5, 0x4000000000000L, active6, 0x600000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000000e0000L, active11, 0L, active12, 0L); + case 71: + case 103: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(2, 36, 76); + else if ((active4 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(2, 290, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x9c000000000L, active1, 0L, active2, 0x800000L, active3, 0L, active4, 0L, active5, 0L, active6, 0xf800000000000000L, active7, 0x20000fL, active8, 0L, active9, 0L, active10, 0x4000000000000000L, active11, 0L, active12, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x8000002008000000L, active6, 0L, active7, 0xc000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 73: + case 105: + if ((active6 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(2, 417, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x6000000000000000L, active1, 0L, active2, 0L, active3, 0x8020000000000010L, active4, 0x100001L, active5, 0x10004000000000L, active6, 0x700000000000L, active7, 0x400000L, active8, 0x10L, active9, 0xfc000000000000L, active10, 0x20040000010006L, active11, 0x100L, active12, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 75: + case 107: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0xc00000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L, active12, 0L); + case 76: + case 108: + if ((active0 & 0x1000L) != 0L) + { + jjmatchedKind = 12; + jjmatchedPos = 2; + } + else if ((active8 & 0x1000L) != 0L) + { + jjmatchedKind = 524; + jjmatchedPos = 2; + } + else if ((active10 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(2, 683, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x30000000006000L, active1, 0x1fe0000L, active2, 0x1000000L, active3, 0x800010041400L, active4, 0L, active5, 0x80078010100300L, active6, 0L, active7, 0x18000003800030L, active8, 0xffffffffffffe000L, active9, 0x1L, active10, 0xa200000000700000L, active11, 0x2L, active12, 0L); + case 77: + case 109: + if ((active9 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(2, 595, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x400L, active1, 0x1000001e000000L, active2, 0x8000000000L, active3, 0xc0000000000000L, active4, 0x1000000000000L, active5, 0x180000e00002L, active6, 0L, active7, 0L, active8, 0x46L, active9, 0x400000fc8100000L, active10, 0x2800000000000L, active11, 0x20L, active12, 0L); + case 78: + case 110: + if ((active5 & 0x400L) != 0L) + { + jjmatchedKind = 330; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x8000100000000000L, active1, 0xfffe0000000L, active2, 0xe00002000000L, active3, 0x10000320002000L, active4, 0x80800000002L, active5, 0x201063800L, active6, 0xc000000000000L, active7, 0x8020000400000000L, active8, 0L, active9, 0x1000000000L, active10, 0x401000000060L, active11, 0x8L, active12, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa3_4(active0, 0xc00100000000L, active1, 0x4000000006000L, active2, 0x200100000000000L, active3, 0x1e1408030000L, active4, 0x1fe70004L, active5, 0L, active6, 0x800000000000L, active7, 0xf0000000000L, active8, 0x1L, active9, 0L, active10, 0x10000000000000L, active11, 0L, active12, 0L); + case 80: + case 112: + if ((active3 & 0x20L) != 0L) + { + jjmatchedKind = 197; + jjmatchedPos = 2; + } + else if ((active3 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(2, 240, 76); + else if ((active4 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(2, 312, 76); + return jjMoveStringLiteralDfa3_4(active0, 0x80000L, active1, 0L, active2, 0x8000004000000L, active3, 0x300000000000040L, active4, 0x8L, active5, 0L, active6, 0L, active7, 0x400000000000c0L, active8, 0L, active9, 0x800004000000000L, active10, 0x110L, active11, 0L, active12, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 82: + case 114: + if ((active3 & 0x80000L) != 0L) + { + jjmatchedKind = 211; + jjmatchedPos = 2; + } + else if ((active6 & 0x800000L) != 0L) + { + jjmatchedKind = 407; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x40020001e00000L, active1, 0xffe0300000000000L, active2, 0x800000018000007L, active3, 0x70c000L, active4, 0x1000000000L, active5, 0xc00080004L, active6, 0x43f01ff00L, active7, 0x700100000000000L, active8, 0L, active9, 0x702L, active10, 0x100001003f800000L, active11, 0x10L, active12, 0L); + case 83: + case 115: + if ((active0 & 0x10L) != 0L) + { + jjmatchedKind = 4; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x780000030000060L, active1, 0L, active2, 0x40079e0000000L, active3, 0x40000000L, active4, 0x60000000f0L, active5, 0x20000038L, active6, 0x18001e0000L, active7, 0x1800000000001f00L, active8, 0L, active9, 0x1000000000e00000L, active10, 0x200L, active11, 0x1L, active12, 0L); + case 84: + case 116: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(2, 45, 76); + else if ((active2 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(2, 168, 76); + else if ((active3 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(2, 227, 76); + else if ((active4 & 0x100L) != 0L) + { + jjmatchedKind = 264; + jjmatchedPos = 2; + } + else if ((active5 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(2, 356, 76); + else if ((active6 & 0x1L) != 0L) + { + jjmatchedKind = 384; + jjmatchedPos = 2; + } + else if ((active7 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 509; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x1801040e00008880L, active1, 0L, active2, 0x2000001f0L, active3, 0x4000000b80L, active4, 0x3e00008000003e00L, active5, 0x601800006000040L, active6, 0x600006L, active7, 0x40000000000fe000L, active8, 0L, active9, 0L, active10, 0x10000e000000000L, active11, 0L, active12, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0x400000000000L, active2, 0x400020000000000L, active3, 0x6000000800000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000000L, active8, 0x80L, active9, 0x300000000000000L, active10, 0L, active11, 0L, active12, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0x1800000000000L, active2, 0L, active3, 0x200000000000L, active4, 0x100000084000L, active5, 0L, active6, 0x40000000L, active7, 0x800100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 87: + case 119: + if ((active2 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(2, 170, 76); + else if ((active5 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(2, 350, 76); + else if ((active7 & 0x40000000L) != 0L) + { + jjmatchedKind = 478; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x40000000000000L, active5, 0L, active6, 0x2000000000L, active7, 0x380000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 88: + case 120: + if ((active4 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 318; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x80000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + case 89: + case 121: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(2, 18, 76); + else if ((active2 & 0x200L) != 0L) + { + jjmatchedKind = 137; + jjmatchedPos = 2; + } + else if ((active2 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(2, 171, 76); + else if ((active4 & 0x40000000L) != 0L) + { + jjmatchedKind = 286; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_4(active0, 0x40000000L, active1, 0L, active2, 0x400L, active3, 0L, active4, 0x180000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x800L, active10, 0L, active11, 0x40L, active12, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa3_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8L, active9, 0L, active10, 0L, active11, 0L, active12, 0L); + default : + break; + } + return jjStartNfa_4(1, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, active12); +} +private final int jjMoveStringLiteralDfa3_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11, long old12, long active12) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11) | (active12 &= old12)) == 0L) + return jjStartNfa_4(1, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, old12); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 3; + } + switch(curChar) + { + case 45: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 49: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x40000L, active11, 0L); + case 51: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x80000L, active11, 0L); + case 56: + if ((active10 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(3, 657, 76); + break; + case 95: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0x180000000000000L, active3, 0L, active4, 0x180000000L, active5, 0x2000000000L, active6, 0L, active7, 0x180000000L, active8, 0xffffffffffff0000L, active9, 0x4000000001L, active10, 0x1800000L, active11, 0L); + case 65: + case 97: + if ((active2 & 0x10L) != 0L) + { + jjmatchedKind = 132; + jjmatchedPos = 3; + } + else if ((active4 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(3, 275, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x1802100001e10000L, active1, 0x3800000000000L, active2, 0x1400e08800032020L, active3, 0x12000L, active4, 0x3c000000000000L, active5, 0x8000000L, active6, 0x7f00L, active7, 0x40000000000010L, active8, 0L, active9, 0x2000000000000L, active10, 0x11000000000000a0L, active11, 0L); + case 66: + case 98: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(3, 46, 76); + else if ((active1 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(3, 77, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0x20000000000L, active3, 0x1000000000L, active4, 0L, active5, 0x80000000002L, active6, 0L, active7, 0L, active8, 0L, active9, 0x400000000000000L, active10, 0x2000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x20000000L) != 0L) + { + jjmatchedKind = 157; + jjmatchedPos = 3; + } + else if ((active3 & 0x4L) != 0L) + { + jjmatchedKind = 194; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_4(active0, 0x180000000000000L, active1, 0x400L, active2, 0x2000011c0000000L, active3, 0x21000808L, active4, 0x3e00000000000000L, active5, 0L, active6, 0x81c08f020000L, active7, 0L, active8, 0xf00L, active9, 0x1000000000041000L, active10, 0x4000000L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(3, 239, 76); + else if ((active4 & 0x10000000000L) != 0L) + { + jjmatchedKind = 296; + jjmatchedPos = 3; + } + else if ((active6 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 436; + jjmatchedPos = 3; + } + else if ((active11 & 0x100L) != 0L) + return jjStartNfaWithStates_4(3, 712, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x40000000000000L, active1, 0xe0000000L, active2, 0L, active3, 0L, active4, 0x20000010000L, active5, 0L, active6, 0x20000000000000L, active7, 0L, active8, 0L, active9, 0xc0L, active10, 0x1000000000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 57, 76); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 115, 76); + else if ((active2 & 0x40L) != 0L) + { + jjmatchedKind = 134; + jjmatchedPos = 3; + } + else if ((active2 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 178, 76); + else if ((active3 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(3, 218, 76); + else if ((active4 & 0x400000000000L) != 0L) + { + jjmatchedKind = 302; + jjmatchedPos = 3; + } + else if ((active5 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(3, 339, 76); + else if ((active5 & 0x400000L) != 0L) + { + jjmatchedKind = 342; + jjmatchedPos = 3; + } + else if ((active5 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(3, 353, 76); + else if ((active7 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(3, 471, 76); + else if ((active8 & 0x8L) != 0L) + return jjStartNfaWithStates_4(3, 515, 76); + else if ((active8 & 0x40L) != 0L) + return jjStartNfaWithStates_4(3, 518, 76); + else if ((active9 & 0x40000000L) != 0L) + { + jjmatchedKind = 606; + jjmatchedPos = 3; + } + else if ((active9 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 632, 76); + else if ((active9 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 635, 76); + else if ((active10 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(3, 686, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x10008820L, active1, 0x10000000000000L, active2, 0xc0000002090c0180L, active3, 0xc0000300200180L, active4, 0x40908200001e32L, active5, 0xb001b00000800000L, active6, 0x600002000000002L, active7, 0x800c800000160L, active8, 0x2000L, active9, 0xf80000100L, active10, 0x800000000000341L, active11, 0L); + case 70: + case 102: + if ((active7 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 500, 76); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0x400000000L, active3, 0L, active4, 0x81800000000L, active5, 0x4L, active6, 0x4000000000000L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x4000000000000400L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 48, 76); + else if ((active2 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 176, 76); + else if ((active6 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(3, 405, 76); + else if ((active10 & 0x2000000000L) != 0L) + { + jjmatchedKind = 677; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_4(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x40L, active6, 0L, active7, 0x200000L, active8, 0L, active9, 0L, active10, 0xc000c000000000L, active11, 0L); + case 73: + case 105: + if ((active10 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(3, 687, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x9c020000480L, active1, 0x1L, active2, 0x10704000L, active3, 0x4000200040000000L, active4, 0x1000000000000L, active5, 0x4600000002008000L, active6, 0x1810000000L, active7, 0x100000000000000L, active8, 0x2L, active9, 0x8000000200L, active10, 0x2008000000000010L, active11, 0L); + case 75: + case 107: + if ((active6 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 435, 76); + else if ((active7 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 498, 76); + else if ((active10 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(3, 671, 76); + else if ((active10 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(3, 680, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x20000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400000L, active8, 0L, active9, 0L, active10, 0x4000000000000L, active11, 0L); + case 76: + case 108: + if ((active0 & 0x10000000000000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + } + else if ((active0 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 61; + jjmatchedPos = 3; + } + else if ((active3 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(3, 220, 76); + else if ((active5 & 0x8000000000L) != 0L) + { + jjmatchedKind = 359; + jjmatchedPos = 3; + } + else if ((active6 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 438, 76); + else if ((active11 & 0x2L) != 0L) + return jjStartNfaWithStates_4(3, 705, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x4020800000080000L, active1, 0x7e8000L, active2, 0x8808L, active3, 0x1900000000040043L, active4, 0x40000L, active5, 0x74000000300L, active6, 0x1000000000000L, active7, 0x3003000080L, active8, 0x20L, active9, 0x7000800L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active3 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(3, 219, 76); + else if ((active9 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 630; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_4(active0, 0x140000000L, active1, 0x1e000000L, active2, 0x2000000000000L, active3, 0x402100000L, active4, 0L, active5, 0xc00000000L, active6, 0x100020000000L, active7, 0L, active8, 0L, active9, 0x80000000102000L, active10, 0x10000000000000L, active11, 0L); + case 78: + case 110: + if ((active4 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(3, 276, 76); + else if ((active4 & 0x200000L) != 0L) + { + jjmatchedKind = 277; + jjmatchedPos = 3; + } + else if ((active5 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 376, 76); + else if ((active6 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(3, 416, 76); + else if ((active9 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(3, 604, 76); + else if ((active10 & 0x100000000L) != 0L) + { + jjmatchedKind = 672; + jjmatchedPos = 3; + } + else if ((active11 & 0x4L) != 0L) + return jjStartNfaWithStates_4(3, 706, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x20008000000L, active1, 0x400700000000L, active2, 0L, active3, 0x8018000800000L, active4, 0x1fc00000L, active5, 0L, active6, 0L, active7, 0x400000000L, active8, 0L, active9, 0x201ff0000000000L, active10, 0x200010008L, active11, 0x40L); + case 79: + case 111: + if ((active3 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(3, 230, 76); + else if ((active4 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(3, 269, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x2000006040L, active1, 0x10000L, active2, 0x810000000000000L, active3, 0x210000000020000L, active4, 0x4000L, active5, 0x11000000L, active6, 0x200040000000L, active7, 0xd00000100000L, active8, 0L, active9, 0xe000000000000000L, active10, 0x8000000000000002L, active11, 0L); + case 80: + case 112: + if ((active2 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(3, 172, 76); + else if ((active8 & 0x10L) != 0L) + return jjStartNfaWithStates_4(3, 516, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0x2000000000L, active3, 0L, active4, 0L, active5, 0x200000L, active6, 0x20000000004L, active7, 0xf0000000200L, active8, 0x4L, active9, 0x8000000L, active10, 0x2020000000000L, active11, 0x20L); + case 81: + case 113: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x2L) != 0L) + { + jjmatchedKind = 65; + jjmatchedPos = 3; + } + else if ((active1 & 0x100000000000L) != 0L) + { + jjmatchedKind = 108; + jjmatchedPos = 3; + } + else if ((active3 & 0x2000000000000L) != 0L) + { + jjmatchedKind = 241; + jjmatchedPos = 3; + } + else if ((active6 & 0x8L) != 0L) + { + jjmatchedKind = 387; + jjmatchedPos = 3; + } + else if ((active10 & 0x800L) != 0L) + { + jjmatchedKind = 651; + jjmatchedPos = 3; + } + else if ((active10 & 0x100000000000L) != 0L) + { + jjmatchedKind = 684; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_4(active0, 0x600000000L, active1, 0xffe02000000003fcL, active2, 0x2000000000800001L, active3, 0x2004400000000200L, active4, 0x200000000000L, active5, 0x80L, active6, 0xf802000000000070L, active7, 0x20000000000fL, active8, 0x80L, active9, 0x4L, active10, 0x40020040000f000L, active11, 0x80L); + case 83: + case 115: + if ((active2 & 0x400L) != 0L) + return jjStartNfaWithStates_4(3, 138, 76); + else if ((active7 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(3, 481, 76); + else if ((active7 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 510, 76); + else if ((active9 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(3, 605, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0x401f800005800L, active2, 0x2000006L, active3, 0xc410L, active4, 0L, active5, 0x4000000000039L, active6, 0x400000c0000L, active7, 0x1820000000000000L, active8, 0x4000L, active9, 0x3c000L, active10, 0x30000000L, active11, 0x1L); + case 84: + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 58, 76); + else if ((active4 & 0x2000000000L) != 0L) + { + jjmatchedKind = 293; + jjmatchedPos = 3; + } + else if ((active4 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(3, 298, 76); + else if ((active5 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(3, 351, 76); + else if ((active5 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 372, 76); + else if ((active6 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(3, 404, 76); + else if ((active9 & 0x2L) != 0L) + return jjStartNfaWithStates_4(3, 577, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x8000000000000000L, active1, 0x60000000000L, active2, 0x8004004000000L, active3, 0x8000000000401000L, active4, 0x40000000c1L, active5, 0x20160000L, active6, 0x400418000L, active7, 0x100003c000c00L, active8, 0L, active9, 0xe00038L, active10, 0x20040800000000L, active11, 0x8L); + case 85: + case 117: + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0x1800000L, active2, 0L, active3, 0x1e0000000000L, active4, 0xcL, active5, 0x400004011800L, active6, 0x80000000000000L, active7, 0x80820000000ff000L, active8, 0L, active9, 0x400L, active10, 0x200000000700000L, active11, 0L); + case 86: + case 118: + if ((active6 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(3, 427, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0x80000000000L, active2, 0L, active3, 0L, active4, 0x8000000000000000L, active5, 0x2000L, active6, 0x400000000000L, active7, 0x600000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x10L); + case 87: + case 119: + if ((active8 & 0x1L) != 0L) + return jjStartNfaWithStates_4(3, 512, 76); + else if ((active10 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(3, 670, 76); + return jjMoveStringLiteralDfa4_4(active0, 0x40000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active5 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(3, 375, 76); + return jjMoveStringLiteralDfa4_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x20000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000L, active10, 0x8000000L, active11, 0L); + default : + break; + } + return jjStartNfa_4(2, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa4_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(2, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 4; + } + switch(curChar) + { + case 50: + if ((active10 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(4, 659, 76); + break; + case 54: + if ((active10 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(4, 658, 76); + break; + case 95: + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0x10000000000004L, active2, 0L, active3, 0x1000000L, active4, 0x80401fc00000L, active5, 0L, active6, 0xf800000000000000L, active7, 0xfL, active8, 0L, active9, 0x80000000000000L, active10, 0x10000000000f000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa5_4(active0, 0x180000000000000L, active1, 0x200063e03f8L, active2, 0x2000008000L, active3, 0x401000100240L, active4, 0x80002000000400c0L, active5, 0x10c00002038L, active6, 0x120000020000L, active7, 0x1000010000004e0L, active8, 0x8000L, active9, 0x1000000000000100L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active5 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(4, 348, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0x20L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1000000L, active8, 0x1f0000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active11 & 0x40L) != 0L) + return jjStartNfaWithStates_4(4, 710, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x2000L, active1, 0L, active2, 0L, active3, 0x4000000000000000L, active4, 0L, active5, 0x200000000000L, active6, 0L, active7, 0x8200080000000L, active8, 0x600080L, active9, 0x200000000000400L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active3 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(4, 215, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x2000000000000L, active1, 0L, active2, 0x10000000002000L, active3, 0xc0000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active1 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(4, 78, 76); + else if ((active2 & 0x8L) != 0L) + return jjStartNfaWithStates_4(4, 131, 76); + else if ((active3 & 0x400L) != 0L) + return jjStartNfaWithStates_4(4, 202, 76); + else if ((active3 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 245, 76); + else if ((active4 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(4, 292, 76); + else if ((active5 & 0x4L) != 0L) + return jjStartNfaWithStates_4(4, 322, 76); + else if ((active5 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(4, 358, 76); + else if ((active6 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 434, 76); + else if ((active7 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(4, 470, 76); + else if ((active7 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(4, 485, 76); + else if ((active7 & 0x10000000000L) != 0L) + { + jjmatchedKind = 488; + jjmatchedPos = 4; + } + else if ((active8 & 0x100L) != 0L) + return jjStartNfaWithStates_4(4, 520, 76); + else if ((active9 & 0x8L) != 0L) + { + jjmatchedKind = 579; + jjmatchedPos = 4; + } + else if ((active9 & 0x800L) != 0L) + return jjStartNfaWithStates_4(4, 587, 76); + else if ((active9 & 0x1000000L) != 0L) + { + jjmatchedKind = 600; + jjmatchedPos = 4; + } + else if ((active10 & 0x400L) != 0L) + return jjStartNfaWithStates_4(4, 650, 76); + else if ((active10 & 0x100000L) != 0L) + { + jjmatchedKind = 660; + jjmatchedPos = 4; + } + else if ((active10 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(4, 674, 76); + else if ((active10 & 0x40000000000L) != 0L) + { + jjmatchedKind = 682; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_4(active0, 0x20840000000000L, active1, 0xffe0280700408000L, active2, 0x42000002800001L, active3, 0x2100000402001000L, active4, 0x20000L, active5, 0x4080000000202L, active6, 0x84c00f400000L, active7, 0x6800e0000000200L, active8, 0L, active9, 0x6f440d0L, active10, 0x2e0000200600000L, active11, 0L); + case 70: + case 102: + if ((active2 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(4, 155, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0L, active5, 0x8000L, active6, 0L, active7, 0L, active8, 0x4000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active10 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(4, 656, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x20000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x200L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x3c000000000000L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(4, 154, 76); + else if ((active2 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 185, 76); + else if ((active3 & 0x800L) != 0L) + return jjStartNfaWithStates_4(4, 203, 76); + else if ((active4 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 313; + jjmatchedPos = 4; + } + else if ((active5 & 0x20000L) != 0L) + { + jjmatchedKind = 337; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x3c00000000000000L, active5, 0x40000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x804000000L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa5_4(active0, 0x4040000700000000L, active1, 0x400f8000000L, active2, 0xc000000000L, active3, 0x8000000000200000L, active4, 0x20000000001L, active5, 0x20020100100L, active6, 0x1410480058000L, active7, 0x182100043c000000L, active8, 0x1fff8000e00L, active9, 0x1000000020L, active10, 0x401000403a000000L, active11, 0x18L); + case 75: + case 107: + if ((active1 & 0x400L) != 0L) + return jjStartNfaWithStates_4(4, 74, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000L, active5, 0L, active6, 0L, active7, 0x100000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 76: + case 108: + if ((active1 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(4, 80, 76); + else if ((active3 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(4, 205, 76); + else if ((active4 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(4, 289, 76); + else if ((active4 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(4, 300, 76); + else if ((active4 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 306; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_4(active0, 0x1800000000000040L, active1, 0L, active2, 0x400020800000800L, active3, 0L, active4, 0x18000000000000L, active5, 0x10000L, active6, 0x30L, active7, 0x100000001000L, active8, 0xe0000000026L, active9, 0x40000c000001000L, active10, 0x1002000000000000L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa5_4(active0, 0x40000000L, active1, 0x1800000L, active2, 0xe00000004000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0x7f00L, active7, 0xc000000000L, active8, 0L, active9, 0x4000000000000000L, active10, 0x20L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x400L) != 0L) + return jjStartNfaWithStates_4(4, 10, 76); + else if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 4; + } + else if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_4(4, 64, 76); + else if ((active10 & 0x2L) != 0L) + return jjStartNfaWithStates_4(4, 641, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x98000000020L, active1, 0L, active2, 0x400700000L, active3, 0x200000000080L, active4, 0x10L, active5, 0x4000000000000000L, active6, 0L, active7, 0xc00100000000L, active8, 0xf00000000000L, active9, 0x8000000000000200L, active10, 0x2008000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa5_4(active0, 0x20800000080L, active1, 0L, active2, 0x1000000006L, active3, 0x40040000L, active4, 0x10000L, active5, 0x6000000020000c0L, active6, 0x10000000L, active7, 0L, active8, 0L, active9, 0x8000000L, active10, 0x9000000008L, active11, 0L); + case 80: + case 112: + if ((active3 & 0x20000000000L) != 0L) + { + jjmatchedKind = 233; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0xd100000000000000L, active3, 0x1c0000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x800000000L, active8, 0L, active9, 0L, active10, 0x20000800000L, active11, 0L); + case 82: + case 114: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_4(4, 11, 76); + else if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(4, 15, 76); + else if ((active2 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 187, 76); + else if ((active3 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(4, 209, 76); + else if ((active4 & 0x2L) != 0L) + return jjStartNfaWithStates_4(4, 257, 76); + else if ((active4 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 310, 76); + else if ((active5 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(4, 347, 76); + else if ((active5 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 380; + jjmatchedPos = 4; + } + else if ((active6 & 0x2L) != 0L) + return jjStartNfaWithStates_4(4, 385, 76); + else if ((active6 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(4, 421, 76); + else if ((active6 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(4, 429, 76); + else if ((active10 & 0x1L) != 0L) + return jjStartNfaWithStates_4(4, 640, 76); + else if ((active10 & 0x100L) != 0L) + return jjStartNfaWithStates_4(4, 648, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x102010000000L, active1, 0x1800000000000L, active2, 0x3c00c0000L, active3, 0x210000300400100L, active4, 0x8000001c20L, active5, 0xa000500004000000L, active6, 0x680000000000040L, active7, 0x420000000fe800L, active8, 0x1000000000000L, active9, 0L, active10, 0x200L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 114, 76); + else if ((active3 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 242, 76); + else if ((active5 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(4, 341, 76); + else if ((active5 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(4, 343, 76); + else if ((active5 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(4, 362, 76); + else if ((active6 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 437, 76); + else if ((active7 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 511, 76); + else if ((active10 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(4, 685, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x8000000L, active1, 0x1800L, active2, 0L, active3, 0L, active4, 0L, active5, 0x1000000L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x1ff0380000000L, active10, 0x1000040L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(4, 110, 76); + else if ((active3 & 0x4000L) != 0L) + { + jjmatchedKind = 206; + jjmatchedPos = 4; + } + else if ((active3 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(4, 208, 76); + else if ((active3 & 0x8000000000L) != 0L) + { + jjmatchedKind = 231; + jjmatchedPos = 4; + } + else if ((active4 & 0x4L) != 0L) + return jjStartNfaWithStates_4(4, 258, 76); + else if ((active4 & 0x8L) != 0L) + return jjStartNfaWithStates_4(4, 259, 76); + else if ((active4 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 304, 76); + else if ((active6 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(4, 414, 76); + else if ((active7 & 0x100L) != 0L) + return jjStartNfaWithStates_4(4, 456, 76); + else if ((active7 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(4, 469, 76); + else if ((active9 & 0x4L) != 0L) + return jjStartNfaWithStates_4(4, 578, 76); + else if ((active9 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 625, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0x201f800000000L, active2, 0x1000180L, active3, 0x8010020008010L, active4, 0x20080100000000L, active5, 0x1800000001800L, active6, 0x2001800080000L, active7, 0x10L, active8, 0x7ffc000000004000L, active9, 0x38000L, active10, 0x80L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa5_4(active0, 0x8000000000000000L, active1, 0L, active2, 0x30000L, active3, 0x180000000000000bL, active4, 0x800000000L, active5, 0x1L, active6, 0x20000004L, active7, 0x2000000L, active8, 0L, active9, 0x2000000000002000L, active10, 0x4000000000004L, active11, 0x20L); + case 86: + case 118: + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0x10000000L, active3, 0L, active4, 0L, active5, 0x2000000000L, active6, 0L, active7, 0L, active8, 0x8000000000000000L, active9, 0x1L, active10, 0x10L, active11, 0L); + case 87: + case 119: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(4, 14, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0x1L); + case 88: + case 120: + if ((active10 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 699, 76); + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(4, 19, 76); + else if ((active0 & 0x200000L) != 0L) + { + jjmatchedKind = 21; + jjmatchedPos = 4; + } + else if ((active2 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 179, 76); + else if ((active2 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(4, 189, 76); + else if ((active11 & 0x80L) != 0L) + return jjStartNfaWithStates_4(4, 711, 76); + return jjMoveStringLiteralDfa5_4(active0, 0x1c10000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x400000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa5_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xc00000000L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_4(3, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa5_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(3, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 5; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa6_4(active0, 0x18001c00000L, active1, 0x1800000001000L, active2, 0x2000000L, active3, 0x40002008000L, active4, 0x3000000000000000L, active5, 0x800000000000L, active6, 0L, active7, 0xe0000000000L, active8, 0L, active9, 0x2000000L, active10, 0x2e0000800400000L, active11, 0L); + case 65: + case 97: + if ((active7 & 0x4000000000L) != 0L) + { + jjmatchedKind = 486; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_4(active0, 0x800000002000L, active1, 0L, active2, 0x100000000004020L, active3, 0xc000000300400000L, active4, 0x8800c20001L, active5, 0x4000002004000000L, active6, 0x1800000000008030L, active7, 0x40008001000000L, active8, 0x8000000000804002L, active9, 0x2800f0000001001L, active10, 0x2000005000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa6_4(active0, 0x600000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x100000000L) != 0L) + { + jjmatchedKind = 32; + jjmatchedPos = 5; + } + else if ((active6 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 432, 76); + else if ((active9 & 0x20L) != 0L) + return jjStartNfaWithStates_4(5, 581, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0x7004003f8L, active2, 0L, active3, 0x200L, active4, 0L, active5, 0L, active6, 0x2000000000000000L, active7, 0x280L, active8, 0x300000002000L, active9, 0L, active10, 0x10000000000000L, active11, 0x10L); + case 68: + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 53, 76); + else if ((active3 & 0x80L) != 0L) + return jjStartNfaWithStates_4(5, 199, 76); + else if ((active5 & 0x40L) != 0L) + return jjStartNfaWithStates_4(5, 326, 76); + else if ((active6 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(5, 412, 76); + else if ((active7 & 0x400000000000L) != 0L) + { + jjmatchedKind = 494; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_4(active0, 0x180000000000000L, active1, 0x10000000000000L, active2, 0L, active3, 0x1800000000000003L, active4, 0L, active5, 0L, active6, 0x80c000000000L, active7, 0x800000000000L, active8, 0L, active9, 0x8000000000000000L, active10, 0xf000L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(5, 37, 76); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 113, 76); + else if ((active2 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(5, 141, 76); + else if ((active2 & 0x100000L) != 0L) + { + jjmatchedKind = 148; + jjmatchedPos = 5; + } + else if ((active2 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(5, 151, 76); + else if ((active2 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(5, 152, 76); + else if ((active2 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(5, 169, 76); + else if ((active2 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 188, 76); + else if ((active3 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 244, 76); + else if ((active5 & 0x800L) != 0L) + { + jjmatchedKind = 331; + jjmatchedPos = 5; + } + else if ((active5 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(5, 336, 76); + else if ((active7 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(5, 468, 76); + else if ((active8 & 0x4L) != 0L) + return jjStartNfaWithStates_4(5, 514, 76); + else if ((active8 & 0x80L) != 0L) + return jjStartNfaWithStates_4(5, 519, 76); + else if ((active9 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 634, 76); + else if ((active10 & 0x4L) != 0L) + return jjStartNfaWithStates_4(5, 642, 76); + else if ((active10 & 0x80L) != 0L) + return jjStartNfaWithStates_4(5, 647, 76); + return jjMoveStringLiteralDfa6_4(active0, 0x40040000000L, active1, 0L, active2, 0x10600000L, active3, 0x10000000000L, active4, 0xc00000081004200L, active5, 0x1001000L, active6, 0x602000000007f00L, active7, 0L, active8, 0x1000001000000L, active9, 0x3c004000040000L, active10, 0x2000020000000020L, active11, 0L); + case 70: + case 102: + if ((active5 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(5, 361, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe00L, active9, 0x300000000000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active3 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(5, 237, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x200000L, active4, 0L, active5, 0x38L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200L, active10, 0x8000000000000000L, active11, 0L); + case 72: + case 104: + if ((active4 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(5, 299, 76); + else if ((active7 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(5, 493, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x200000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa6_4(active0, 0x8000000L, active1, 0x20000000800L, active2, 0x10e001c0000180L, active3, 0xc8080020000040L, active4, 0L, active5, 0x2000100000008000L, active6, 0x4000001800000040L, active7, 0x2000000000810L, active8, 0x1c000000070020L, active9, 0x8000008000L, active10, 0x8000000000000L, active11, 0L); + case 76: + case 108: + if ((active3 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(5, 228, 76); + else if ((active6 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(5, 401, 76); + else if ((active7 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(5, 492, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0x4L, active2, 0x800030000L, active3, 0L, active4, 0x8000000000000000L, active5, 0xc00002000L, active6, 0x400000000000L, active7, 0x100000000000000L, active8, 0x4480000L, active9, 0x1c00000002000L, active10, 0x1000000000000000L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100L) != 0L) + return jjStartNfaWithStates_4(5, 584, 76); + else if ((active9 & 0x200000L) != 0L) + { + jjmatchedKind = 597; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x2100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000L, active9, 0x4000000000c00010L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_4(5, 7, 76); + else if ((active1 & 0x800000L) != 0L) + { + jjmatchedKind = 87; + jjmatchedPos = 5; + } + else if ((active2 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(5, 167, 76); + else if ((active3 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(5, 222, 76); + else if ((active5 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 377; + jjmatchedPos = 5; + } + else if ((active7 & 0x2000L) != 0L) + { + jjmatchedKind = 461; + jjmatchedPos = 5; + } + else if ((active10 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(5, 678, 76); + return jjMoveStringLiteralDfa6_4(active0, 0x4040000020000000L, active1, 0xffe0040007000000L, active2, 0x2005000000001L, active3, 0x100L, active4, 0x200000000c0L, active5, 0x400000022000200L, active6, 0x8f040000L, active7, 0x8000043c0fc000L, active8, 0x1fff8000000L, active9, 0x2000001000000000L, active10, 0x400000000a000000L, active11, 0x8L); + case 79: + case 111: + return jjMoveStringLiteralDfa6_4(active0, 0x1800000000000000L, active1, 0L, active2, 0x400000800L, active3, 0L, active4, 0x20000006000000L, active5, 0L, active6, 0x400000000L, active7, 0x1801000880000000L, active8, 0xe0002100000L, active9, 0xc00000000L, active10, 0x30800010L, active11, 0x1L); + case 80: + case 112: + if ((active7 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(5, 473, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000000000000000L, active10, 0x404000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x2L) != 0L) + { + jjmatchedKind = 129; + jjmatchedPos = 5; + } + else if ((active3 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(5, 204, 76); + else if ((active5 & 0x2L) != 0L) + return jjStartNfaWithStates_4(5, 321, 76); + else if ((active5 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(5, 363, 76); + else if ((active7 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(5, 484, 76); + else if ((active7 & 0x200000000000000L) != 0L) + { + jjmatchedKind = 505; + jjmatchedPos = 5; + } + return jjMoveStringLiteralDfa6_4(active0, 0x8000000800000000L, active1, 0x9f800000000L, active2, 0x800000000c8004L, active3, 0x400000000000L, active4, 0xa00000000000L, active5, 0x400000000001L, active6, 0x8000160000400000L, active7, 0x400000000000400L, active8, 0x8000L, active9, 0x8030000L, active10, 0x100000000000000L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(5, 16, 76); + else if ((active2 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 186, 76); + else if ((active3 & 0x10L) != 0L) + return jjStartNfaWithStates_4(5, 196, 76); + else if ((active3 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(5, 236, 76); + else if ((active5 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(5, 338, 76); + else if ((active5 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 368, 76); + else if ((active5 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 383, 76); + else if ((active10 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(5, 661, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0x200000008000L, active2, 0L, active3, 0x1000000L, active4, 0xc10L, active5, 0x100180L, active6, 0x80010000000000L, active7, 0x2fL, active8, 0x7fe0000000000000L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_4(5, 5, 76); + else if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(5, 43, 76); + else if ((active1 & 0x8000000L) != 0L) + { + jjmatchedKind = 91; + jjmatchedPos = 5; + } + else if ((active2 & 0x4000000000000000L) != 0L) + { + jjmatchedKind = 190; + jjmatchedPos = 5; + } + else if ((active3 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(5, 212, 76); + else if ((active3 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 249, 76); + else if ((active4 & 0x20L) != 0L) + return jjStartNfaWithStates_4(5, 261, 76); + else if ((active5 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(5, 365, 76); + else if ((active5 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 370, 76); + else if ((active6 & 0x4L) != 0L) + return jjStartNfaWithStates_4(5, 386, 76); + else if ((active7 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(5, 460, 76); + else if ((active7 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(5, 499, 76); + else if ((active9 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(5, 590, 76); + else if ((active10 & 0x40L) != 0L) + return jjStartNfaWithStates_4(5, 646, 76); + else if ((active10 & 0x200L) != 0L) + return jjStartNfaWithStates_4(5, 649, 76); + return jjMoveStringLiteralDfa6_4(active0, 0x2000010000000L, active1, 0xf03e0000L, active2, 0x8000002000000000L, active3, 0x400000008L, active4, 0x18000000040000L, active5, 0L, active6, 0x20010000L, active7, 0x20000000000040L, active8, 0L, active9, 0x380100400L, active10, 0L, active11, 0x20L); + case 85: + case 117: + return jjMoveStringLiteralDfa6_4(active0, 0x20000000040L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0x400000000000L, active9, 0L, active10, 0x8000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010001000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0xc0L, active10, 0x200000000L, active11, 0L); + case 87: + case 119: + if ((active4 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(5, 272, 76); + else if ((active10 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(5, 676, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x40000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0x40000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(5, 44, 76); + return jjMoveStringLiteralDfa6_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_4(4, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa6_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(4, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 6; + } + switch(curChar) + { + case 50: + if ((active6 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 447, 76); + break; + case 95: + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0xc002c0L, active10, 0x2000000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa7_4(active0, 0x40000000400000L, active1, 0xf800000000L, active2, 0x80000000040000L, active3, 0xc0000000000100L, active4, 0x4010001000L, active5, 0x2000000L, active6, 0L, active7, 0x40L, active8, 0x3800000200000L, active9, 0x1c0038c000000L, active10, 0x2000000L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0x40000000L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x800000000L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x200000000000L) != 0L) + { + jjmatchedKind = 173; + jjmatchedPos = 6; + } + else if ((active5 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(6, 364, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x800000L, active1, 0x8000L, active2, 0xc06000000800L, active3, 0x440000000000L, active4, 0x40L, active5, 0x1000000L, active6, 0L, active7, 0x80020001000800L, active8, 0x1000000L, active9, 0xf0000000000L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active2 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(6, 149, 76); + else if ((active2 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(6, 156, 76); + else if ((active3 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(6, 232, 76); + else if ((active4 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 314, 76); + else if ((active10 & 0x20L) != 0L) + return jjStartNfaWithStates_4(6, 645, 76); + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0x6000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x40L, active7, 0L, active8, 0L, active9, 0x2000000000040000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 6; + } + else if ((active1 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(6, 81, 76); + else if ((active2 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(6, 143, 76); + else if ((active3 & 0x1L) != 0L) + return jjStartNfaWithStates_4(6, 192, 76); + else if ((active3 & 0x8L) != 0L) + return jjStartNfaWithStates_4(6, 195, 76); + else if ((active3 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 251, 76); + else if ((active6 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(6, 413, 76); + else if ((active6 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(6, 425, 76); + else if ((active7 & 0x20L) != 0L) + return jjStartNfaWithStates_4(6, 453, 76); + else if ((active7 & 0x80L) != 0L) + return jjStartNfaWithStates_4(6, 455, 76); + else if ((active7 & 0x4000000L) != 0L) + { + jjmatchedKind = 474; + jjmatchedPos = 6; + } + else if ((active9 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 636, 76); + else if ((active11 & 0x10L) != 0L) + return jjStartNfaWithStates_4(6, 708, 76); + else if ((active11 & 0x20L) != 0L) + return jjStartNfaWithStates_4(6, 709, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x100000000000000L, active1, 0x4L, active2, 0x40000000080000L, active3, 0x2100000001000000L, active4, 0x800000000c00L, active5, 0x4000001081b9L, active6, 0x404000000000L, active7, 0x3803c000L, active8, 0x2000L, active9, 0x10L, active10, 0x110000020000f000L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa7_4(active0, 0x8000000000L, active1, 0x800L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 59; + jjmatchedPos = 6; + } + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 62, 76); + else if ((active4 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(6, 297, 76); + else if ((active5 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(6, 349, 76); + else if ((active6 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(6, 402, 76); + else if ((active6 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(6, 415, 76); + else if ((active7 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(6, 482, 76); + else if ((active10 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(6, 667, 76); + else if ((active10 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 702, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x1000000000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 72: + case 104: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 49, 76); + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x100000000000L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa7_4(active0, 0x810000000L, active1, 0x100000e03c0000L, active2, 0x8000000200000000L, active3, 0x1000000000040002L, active4, 0x18000000040010L, active5, 0xc00000000L, active6, 0x80018000010000L, active7, 0x120000800040000L, active8, 0x7fe0000000000e00L, active9, 0xc000000000030000L, active10, 0x8010000000000000L, active11, 0L); + case 76: + case 108: + if ((active2 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(6, 142, 76); + else if ((active3 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(6, 224, 76); + else if ((active3 & 0x8000000000000000L) != 0L) + { + jjmatchedKind = 255; + jjmatchedPos = 6; + } + else if ((active4 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(6, 295, 76); + else if ((active5 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(6, 346, 76); + else if ((active6 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(6, 399, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x20000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1L, active5, 0x4000812000000000L, active6, 0L, active7, 0x1L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa7_4(active0, 0x21000000L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000000L, active8, 0xc400000000000L, active9, 0L, active10, 0x1000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(6, 42, 76); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(6, 47, 76); + else if ((active3 & 0x40L) != 0L) + return jjStartNfaWithStates_4(6, 198, 76); + else if ((active3 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(6, 213, 76); + else if ((active3 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(6, 214, 76); + else if ((active6 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(6, 406, 76); + else if ((active6 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(6, 418, 76); + else if ((active7 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 496, 76); + else if ((active7 & 0x800000000000000L) != 0L) + { + jjmatchedKind = 507; + jjmatchedPos = 6; + } + else if ((active10 & 0x8L) != 0L) + return jjStartNfaWithStates_4(6, 643, 76); + else if ((active10 & 0x10000000L) != 0L) + { + jjmatchedKind = 668; + jjmatchedPos = 6; + } + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0x20000000000L, active2, 0x10001000000000L, active3, 0x80000000000L, active4, 0x1000000000000000L, active5, 0x2000000000000200L, active6, 0x4600000000000000L, active7, 0x1000040000000000L, active8, 0x100e0000028020L, active9, 0x8c02000000L, active10, 0x80000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0x1000L, active2, 0x800000000L, active3, 0x20000000L, active4, 0L, active5, 0L, active6, 0x2000001800000000L, active7, 0L, active8, 0x4580000L, active9, 0x300000000000L, active10, 0x400000L, active11, 0L); + case 80: + case 112: + if ((active10 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(6, 663, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x10000000000L, active1, 0xa00000000000L, active2, 0x180000000L, active3, 0L, active4, 0x100000000L, active5, 0L, active6, 0x10L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active2 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(6, 150, 76); + else if ((active4 & 0x200L) != 0L) + return jjStartNfaWithStates_4(6, 265, 76); + else if ((active4 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(6, 270, 76); + else if ((active4 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(6, 273, 76); + else if ((active4 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 309, 76); + else if ((active6 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 433, 76); + else if ((active8 & 0x2L) != 0L) + return jjStartNfaWithStates_4(6, 513, 76); + else if ((active9 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 626; + jjmatchedPos = 6; + } + else if ((active10 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(6, 666, 76); + else if ((active10 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(6, 681, 76); + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0x100000002000000L, active3, 0x402000000L, active4, 0x2000000000c00000L, active5, 0L, active6, 0x80000L, active7, 0L, active8, 0x8000000000000000L, active9, 0xb8000000100001L, active10, 0L, active11, 0x1L); + case 83: + case 115: + if ((active4 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 315, 76); + else if ((active5 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(6, 332, 76); + else if ((active5 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 378, 76); + else if ((active7 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(6, 467, 76); + else if ((active7 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(6, 495, 76); + else if ((active10 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 690, 76); + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0x1000000000000L, active2, 0x400000020L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0L, active9, 0x1000L, active10, 0x20000000000000L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(6, 86, 76); + else if ((active1 & 0x100000000L) != 0L) + { + jjmatchedKind = 96; + jjmatchedPos = 6; + } + else if ((active1 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(6, 107, 76); + else if ((active1 & 0x20000000000000L) != 0L) + { + jjmatchedKind = 117; + jjmatchedPos = 6; + } + else if ((active2 & 0x10000L) != 0L) + { + jjmatchedKind = 144; + jjmatchedPos = 6; + } + else if ((active2 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 177, 76); + else if ((active3 & 0x200L) != 0L) + return jjStartNfaWithStates_4(6, 201, 76); + else if ((active6 & 0x1000000L) != 0L) + { + jjmatchedKind = 408; + jjmatchedPos = 6; + } + else if ((active7 & 0x200L) != 0L) + return jjStartNfaWithStates_4(6, 457, 76); + else if ((active7 & 0x400L) != 0L) + return jjStartNfaWithStates_4(6, 458, 76); + else if ((active8 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(6, 530, 76); + else if ((active9 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(6, 612, 76); + else if ((active10 & 0x10L) != 0L) + return jjStartNfaWithStates_4(6, 644, 76); + else if ((active10 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(6, 679, 76); + return jjMoveStringLiteralDfa7_4(active0, 0x48002040L, active1, 0xffc00006100003f8L, active2, 0x20001L, active3, 0x4008000200000000L, active4, 0x80L, active5, 0L, active6, 0xe007f00L, active7, 0x42000000000000L, active8, 0x1fff8804000L, active9, 0x20000000000a000L, active10, 0x60a000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa7_4(active0, 0x600000000L, active1, 0x50000000000L, active2, 0L, active3, 0L, active4, 0x8000000008000000L, active5, 0x2000L, active6, 0x800000000000L, active7, 0x80000000L, active8, 0x2000000L, active9, 0x400L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0x1800040000000000L, active7, 0x10L, active8, 0L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 88: + case 120: + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x6L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(6, 63, 76); + else if ((active4 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(6, 301, 76); + else if ((active6 & 0x20L) != 0L) + return jjStartNfaWithStates_4(6, 389, 76); + else if ((active6 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(6, 428, 76); + return jjMoveStringLiteralDfa7_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_4(5, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa7_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(5, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 7; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa8_4(active0, 0x1000000000000000L, active1, 0xffc0000006000000L, active2, 0xc00000000001L, active3, 0L, active4, 0L, active5, 0x38L, active6, 0x8000000L, active7, 0x1000000038000000L, active8, 0x7fe0000000000000L, active9, 0x38000000000000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa8_4(active0, 0x10001000000L, active1, 0x1000000000000L, active2, 0x2000800L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x60000000000L, active8, 0x100004020000L, active9, 0x2000200L, active10, 0x80000000000000L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(7, 531, 76); + else if ((active8 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(7, 534, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0L, active4, 0x80000000L, active5, 0L, active6, 0L, active7, 0x100000040L, active8, 0x8000000002000000L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active2 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 182, 80); + else if ((active8 & 0x200L) != 0L) + { + jjmatchedKind = 521; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0x10000000000L, active2, 0L, active3, 0x1000000L, active4, 0xc00L, active5, 0x180L, active6, 0x600000000000000L, active7, 0x80000000000L, active8, 0xc00L, active9, 0x1L, active10, 0L, active11, 0L); + case 68: + case 100: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 56, 76); + else if ((active2 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(7, 147, 76); + else if ((active11 & 0x1L) != 0L) + return jjStartNfaWithStates_4(7, 704, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x3c000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x40L) != 0L) + return jjStartNfaWithStates_4(7, 6, 76); + else if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(7, 13, 76); + else if ((active1 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(7, 79, 76); + else if ((active1 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(7, 106, 76); + else if ((active2 & 0x20L) != 0L) + return jjStartNfaWithStates_4(7, 133, 76); + else if ((active2 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(7, 158, 76); + else if ((active4 & 0x40L) != 0L) + return jjStartNfaWithStates_4(7, 262, 76); + else if ((active4 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(7, 288, 76); + else if ((active4 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(7, 291, 76); + else if ((active4 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 319, 76); + else if ((active5 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(7, 333, 76); + else if ((active5 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(7, 360, 76); + else if ((active6 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(7, 426, 76); + else if ((active7 & 0x10L) != 0L) + return jjStartNfaWithStates_4(7, 452, 76); + else if ((active7 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 503, 76); + else if ((active8 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(7, 526, 76); + else if ((active8 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(7, 535, 76); + else if ((active8 & 0x4000000000000L) != 0L) + { + jjmatchedKind = 562; + jjmatchedPos = 7; + } + else if ((active9 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 633, 76); + else if ((active10 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 689, 76); + return jjMoveStringLiteralDfa8_4(active0, 0x20000000L, active1, 0x100003f8L, active2, 0x1000000180L, active3, 0x200000000L, active4, 0x2000000008000000L, active5, 0x800000000000L, active6, 0x7f00L, active7, 0L, active8, 0x841fff8000000L, active9, 0x2000004c00000000L, active10, 0x400000000000000L, active11, 0L); + case 70: + case 102: + if ((active10 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(7, 662, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L, active11, 0L); + case 71: + case 103: + if ((active2 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 180, 76); + else if ((active3 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(7, 235, 76); + else if ((active5 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 381, 76); + else if ((active9 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(7, 615, 76); + return jjMoveStringLiteralDfa8_4(active0, 0x400000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000000000L, active5, 0L, active6, 0x1800400000000000L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0x100000000000000L, active11, 0L); + case 72: + case 104: + if ((active2 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(7, 165, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x400000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa8_4(active0, 0x8000000L, active1, 0xfe00000800L, active2, 0L, active3, 0L, active4, 0x1000080L, active5, 0x4000000000000200L, active6, 0x6000040L, active7, 0L, active8, 0x1018000L, active9, 0x102000L, active10, 0x20000000L, active11, 0L); + case 74: + case 106: + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x6000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active7 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(7, 472, 76); + break; + case 76: + case 108: + if ((active3 & 0x100L) != 0L) + return jjStartNfaWithStates_4(7, 200, 76); + else if ((active4 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(7, 268, 76); + else if ((active5 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(7, 345, 76); + else if ((active8 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 560, 76); + else if ((active10 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 700, 76); + return jjMoveStringLiteralDfa8_4(active0, 0x40020000000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4010000001L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000100000L, active9, 0L, active10, 0L, active11, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0x80000000000000L, active3, 0L, active4, 0x18000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x384000000L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active3 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(7, 221, 76); + else if ((active6 & 0x800000000L) != 0L) + { + jjmatchedKind = 419; + jjmatchedPos = 7; + } + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0x1000004L, active2, 0x200000004L, active3, 0x3100000000040002L, active4, 0L, active5, 0x400000000000L, active6, 0x9000000000L, active7, 0x400008880040000L, active8, 0L, active9, 0x30010L, active10, 0x8000000000000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa8_4(active0, 0x10800000L, active1, 0xa000e03c0000L, active2, 0x8000000000000000L, active3, 0x4000040002000000L, active4, 0x40000L, active5, 0x1000000L, active6, 0x10000090000L, active7, 0x40000000000001L, active8, 0x200000000000L, active9, 0L, active10, 0L, active11, 0x8L); + case 80: + case 112: + if ((active10 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(7, 664, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000L, active9, 0x40L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active8 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(7, 533, 76); + else if ((active10 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(7, 673, 76); + return jjMoveStringLiteralDfa8_4(active0, 0x8040000000L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0xc00000L, active5, 0L, active6, 0x800000000000L, active7, 0L, active8, 0x800000000000L, active9, 0x80300008000400L, active10, 0x40000002000000L, active11, 0L); + case 83: + case 115: + if ((active1 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(7, 105, 76); + else if ((active2 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(7, 145, 76); + else if ((active5 & 0x1L) != 0L) + return jjStartNfaWithStates_4(7, 320, 76); + else if ((active5 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(7, 335, 76); + else if ((active6 & 0x10L) != 0L) + return jjStartNfaWithStates_4(7, 388, 76); + else if ((active6 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(7, 422, 76); + else if ((active9 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(7, 594, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0x10000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1080L, active10, 0x2000000000000000L, active11, 0L); + case 84: + case 116: + if ((active2 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(7, 166, 76); + else if ((active5 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(7, 340, 76); + else if ((active7 & 0x800L) != 0L) + return jjStartNfaWithStates_4(7, 459, 76); + else if ((active8 & 0x20L) != 0L) + return jjStartNfaWithStates_4(7, 517, 76); + return jjMoveStringLiteralDfa8_4(active0, 0x600000000L, active1, 0L, active2, 0x100000580000000L, active3, 0xc0000000000000L, active4, 0x10L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0xc001cf0000400000L, active10, 0x10000000000000L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0x2000000000L, active6, 0x2000000000000000L, active7, 0L, active8, 0L, active9, 0x808000L, active10, 0x800000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x80000000000000L, active7, 0x20000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active2 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(7, 163, 76); + break; + case 88: + case 120: + if ((active7 & 0x2L) != 0L) + return jjStartNfaWithStates_4(7, 449, 76); + break; + case 89: + case 121: + if ((active3 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(7, 226, 76); + else if ((active3 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 243, 76); + else if ((active7 & 0x4L) != 0L) + return jjStartNfaWithStates_4(7, 450, 76); + else if ((active7 & 0x8L) != 0L) + return jjStartNfaWithStates_4(7, 451, 76); + else if ((active7 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(7, 497, 76); + return jjMoveStringLiteralDfa8_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10000000000000L, active9, 0L, active10, 0x228000000000000L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa8_4(active0, 0x800000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0xc00000000L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_4(6, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa8_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(6, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 8; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000000000L, active7, 0x3c000L, active8, 0x400L, active9, 0xc00001000L, active10, 0x8000000000000L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa9_4(active0, 0x8800000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0xc00080L, active5, 0L, active6, 0L, active7, 0x500008000000000L, active8, 0L, active9, 0x80000000000080L, active10, 0L, active11, 0L); + case 66: + case 98: + if ((active8 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(8, 557, 76); + break; + case 67: + case 99: + if ((active9 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(8, 596, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x40000000000000L, active2, 0x1000000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0x400000000000L, active6, 0L, active7, 0x8000000L, active8, 0x800000000000L, active9, 0x8000000000000L, active10, 0x800000000L, active11, 0L); + case 68: + case 100: + if ((active1 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(8, 92, 76); + else if ((active3 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(8, 225, 76); + else if ((active9 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 637, 76); + else if ((active10 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 698, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x180000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x200000000L) != 0L) + { + jjmatchedKind = 33; + jjmatchedPos = 8; + } + else if ((active2 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 183, 76); + else if ((active3 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 246; + jjmatchedPos = 8; + } + else if ((active4 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 307; + jjmatchedPos = 8; + } + else if ((active5 & 0x400000000L) != 0L) + { + jjmatchedKind = 354; + jjmatchedPos = 8; + } + else if ((active5 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(8, 357, 76); + else if ((active6 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(8, 431, 76); + else if ((active6 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 439, 76); + else if ((active7 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 501, 76); + else if ((active9 & 0x400L) != 0L) + return jjStartNfaWithStates_4(8, 586, 76); + else if ((active9 & 0x400000000000L) != 0L) + { + jjmatchedKind = 622; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_4(active0, 0x400000000L, active1, 0x800L, active2, 0L, active3, 0x80000000000000L, active4, 0x10800086000000L, active5, 0x800000000L, active6, 0x4200400000000000L, active7, 0x100000000L, active8, 0x100000L, active9, 0x800000000000L, active10, 0L, active11, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(8, 22, 76); + else if ((active3 & 0x2L) != 0L) + return jjStartNfaWithStates_4(8, 193, 76); + else if ((active3 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(8, 210, 76); + else if ((active3 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 252, 76); + else if ((active6 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(8, 423, 76); + else if ((active7 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(8, 466, 76); + else if ((active9 & 0x10000L) != 0L) + { + jjmatchedKind = 592; + jjmatchedPos = 8; + } + else if ((active10 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 703, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x4L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000L, active9, 0x20200L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x80000000000L, active8, 0x80000000000000L, active9, 0x1L, active10, 0L, active11, 0L); + case 73: + case 105: + if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(8, 41, 76); + return jjMoveStringLiteralDfa9_4(active0, 0x40000040000000L, active1, 0x1000L, active2, 0x100000680000000L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000000L, active9, 0x80010f0000400000L, active10, 0x210000000000f000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0x40000L, active3, 0x8000L, active4, 0L, active5, 0x8L, active6, 0x6000000L, active7, 0x40L, active8, 0x2000002000000L, active9, 0x4000000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active9 & 0x100000000000L) != 0L) + { + jjmatchedKind = 620; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x1000000000000L, active2, 0L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0L, active7, 0x40000000000L, active8, 0x700000001000000L, active9, 0x200002000000L, active10, 0x80000000000000L, active11, 0L); + case 78: + case 110: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(8, 28, 76); + else if ((active1 & 0x40000L) != 0L) + { + jjmatchedKind = 82; + jjmatchedPos = 8; + } + else if ((active1 & 0x20000000L) != 0L) + { + jjmatchedKind = 93; + jjmatchedPos = 8; + } + else if ((active2 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 191, 76); + else if ((active4 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(8, 274, 76); + else if ((active6 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(8, 400, 76); + else if ((active6 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(8, 424, 76); + return jjMoveStringLiteralDfa9_4(active0, 0x1000000020800000L, active1, 0x20f8c0380000L, active2, 0x2000000L, active3, 0x40000000000L, active4, 0L, active5, 0x800001000000L, active6, 0x2000000000000040L, active7, 0x10000000L, active8, 0x18000L, active9, 0x10000000000000L, active10, 0x20000020000000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x600000000L, active2, 0x100000000L, active3, 0x1000000L, active4, 0L, active5, 0x190L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40L, active10, 0x40000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(8, 111, 76); + else if ((active9 & 0x80000000L) != 0L) + { + jjmatchedKind = 607; + jjmatchedPos = 8; + } + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x200000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x1L, active8, 0L, active9, 0x304000000L, active10, 0x200000000000000L, active11, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 82: + case 114: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 8; + } + else if ((active3 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 254, 76); + else if ((active6 & 0x100L) != 0L) + { + jjmatchedKind = 392; + jjmatchedPos = 8; + } + else if ((active7 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 502, 76); + else if ((active8 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_4(8, 556, 76); + return jjMoveStringLiteralDfa9_4(active0, 0x10000000000L, active1, 0xc000000000003f0L, active2, 0L, active3, 0L, active4, 0x8000000L, active5, 0L, active6, 0x8007e00L, active7, 0L, active8, 0x41fff0020000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0x1008000000000000L, active9, 0x20000000802000L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active1 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 116, 76); + else if ((active3 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 253, 76); + else if ((active4 & 0x400L) != 0L) + { + jjmatchedKind = 266; + jjmatchedPos = 8; + } + else if ((active7 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(8, 479, 76); + else if ((active7 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(8, 483, 76); + else if ((active8 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(8, 538, 76); + else if ((active9 & 0x10L) != 0L) + return jjStartNfaWithStates_4(8, 580, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0xe000010000000000L, active2, 0x800L, active3, 0x100000000000000L, active4, 0x800L, active5, 0x4000000000000020L, active6, 0L, active7, 0x20000000000L, active8, 0x2800L, active9, 0x4000000000008000L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x4010000000L, active5, 0x200L, active6, 0x80000L, active7, 0x1000000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0x8L); + case 86: + case 118: + return jjMoveStringLiteralDfa9_4(active0, 0x8000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0L, active10, 0L, active11, 0L); + case 87: + case 119: + if ((active3 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(8, 217, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active6 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 443, 76); + return jjMoveStringLiteralDfa9_4(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 89: + case 121: + if ((active3 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(8, 238, 76); + else if ((active4 & 0x1L) != 0L) + return jjStartNfaWithStates_4(8, 256, 76); + else if ((active6 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 444, 76); + else if ((active9 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(8, 603, 76); + else if ((active10 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(8, 665, 76); + else if ((active10 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(8, 692, 76); + return jjMoveStringLiteralDfa9_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4000000000000000L, active9, 0L, active10, 0L, active11, 0L); + default : + break; + } + return jjStartNfa_4(7, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa9_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(7, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); + return 9; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa10_4(active0, 0x1000000L, active1, 0x803800f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7e00L, active7, 0L, active8, 0L, active9, 0x804000020000L, active10, 0L, active11, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa10_4(active0, 0x1000000000000000L, active1, 0x2c0000040000000L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x8000000L, active7, 0x20018000000L, active8, 0x200e0001100000L, active9, 0x18000100000001L, active10, 0L, active11, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x1000000000000080L, active5, 0L, active6, 0L, active7, 0x100000000000000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 67: + case 99: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(9, 30, 76); + return jjMoveStringLiteralDfa10_4(active0, 0x800000L, active1, 0x1000000000000000L, active2, 0x400000000L, active3, 0x40000000000L, active4, 0x6000000L, active5, 0x10L, active6, 0L, active7, 0x20004000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L, active11, 0L); + case 68: + case 100: + if ((active5 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(9, 344, 76); + else if ((active5 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(9, 355, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x200000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L, active11, 0L); + case 69: + case 101: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(9, 27, 76); + else if ((active2 & 0x800L) != 0L) + return jjStartNfaWithStates_4(9, 139, 76); + else if ((active2 & 0x40000L) != 0L) + return jjStartNfaWithStates_4(9, 146, 76); + else if ((active4 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(9, 284, 76); + else if ((active4 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(9, 294, 76); + else if ((active7 & 0x1L) != 0L) + return jjStartNfaWithStates_4(9, 448, 76); + else if ((active7 & 0x40L) != 0L) + return jjStartNfaWithStates_4(9, 454, 76); + else if ((active7 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(9, 490, 76); + else if ((active8 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(9, 537, 76); + else if ((active9 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(9, 591, 76); + else if ((active9 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(9, 601, 76); + else if ((active10 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 695, 76); + else if ((active10 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 697, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000028L, active6, 0x6000000L, active7, 0x80000000000L, active8, 0x7000000008000000L, active9, 0x4000000000802000L, active10, 0L, active11, 0L); + case 71: + case 103: + if ((active6 & 0x40L) != 0L) + return jjStartNfaWithStates_4(9, 390, 76); + else if ((active8 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(9, 527, 76); + else if ((active9 & 0x200L) != 0L) + return jjStartNfaWithStates_4(9, 585, 76); + else if ((active10 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(9, 669, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x1000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x800000000000L, active6, 0x80000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000L, active9, 0x400000000L, active10, 0L, active11, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x6000000000000100L, active2, 0x180L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0L, active7, 0L, active8, 0x302400000002000L, active9, 0L, active10, 0L, active11, 0L); + case 75: + case 107: + if ((active2 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(9, 153, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000800000000L, active11, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x80000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0L, active9, 0x4000000L, active10, 0L, active11, 0L); + case 77: + case 109: + if ((active5 & 0x200L) != 0L) + return jjStartNfaWithStates_4(9, 329, 76); + return jjMoveStringLiteralDfa10_4(active0, 0x8000000000L, active1, 0x1000000L, active2, 0x4L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x400008000000000L, active8, 0L, active9, 0x800400080L, active10, 0L, active11, 0L); + case 78: + case 110: + if ((active1 & 0x200000000L) != 0L) + { + jjmatchedKind = 97; + jjmatchedPos = 9; + } + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x400000000L, active2, 0L, active3, 0x1000000L, active4, 0L, active5, 0x180L, active6, 0x400000000000000L, active7, 0L, active8, 0x8010000000000400L, active9, 0L, active10, 0xf000L, active11, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0xc00010000000000L, active2, 0x80000000L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x480000000000000L, active9, 0x80010f0000001000L, active10, 0x100000000000000L, active11, 0L); + case 80: + case 112: + if ((active1 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 112, 76); + else if ((active9 & 0x40L) != 0L) + return jjStartNfaWithStates_4(9, 582, 76); + break; + case 82: + case 114: + if ((active1 & 0x800L) != 0L) + return jjStartNfaWithStates_4(9, 75, 76); + else if ((active2 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(9, 160, 76); + else if ((active4 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(9, 287, 76); + else if ((active7 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(9, 480, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000001000000000L, active7, 0L, active8, 0x40000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 83: + case 115: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(9, 34, 76); + else if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_4(9, 73, 76); + else if ((active6 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(9, 430, 76); + else if ((active6 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 441, 76); + else if ((active9 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(9, 621, 76); + else if ((active11 & 0x8L) != 0L) + return jjStartNfaWithStates_4(9, 707, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0x200000001L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0L, active7, 0x1000000000020000L, active8, 0L, active9, 0L, active10, 0L, active11, 0L); + case 84: + case 116: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(9, 29, 76); + else if ((active1 & 0x800000000L) != 0L) + { + jjmatchedKind = 99; + jjmatchedPos = 9; + } + else if ((active2 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(9, 164, 76); + else if ((active6 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 445, 76); + else if ((active8 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(9, 528, 76); + return jjMoveStringLiteralDfa10_4(active0, 0x40010800000000L, active1, 0xf000000004L, active2, 0x100000000000000L, active3, 0L, active4, 0x1000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000000L, active9, 0L, active10, 0L, active11, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0x8000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0L, active10, 0x40000000000000L, active11, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x10L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1fff0000000L, active9, 0L, active10, 0L, active11, 0L); + case 88: + case 120: + if ((active4 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(9, 303, 76); + break; + case 89: + case 121: + if ((active4 & 0x400000L) != 0L) + { + jjmatchedKind = 278; + jjmatchedPos = 9; + } + else if ((active4 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(9, 283, 76); + else if ((active5 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 382, 76); + else if ((active8 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(9, 529, 76); + else if ((active9 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(9, 631, 76); + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L, active11, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa10_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000000000000000L, active11, 0L); + default : + break; + } + return jjStartNfa_4(8, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, active11, 0L); +} +private final int jjMoveStringLiteralDfa10_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10, long old11, long active11) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10) | (active11 &= old11)) == 0L) + return jjStartNfa_4(8, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, old11, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 10; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x7400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x6000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa11_4(active0, 0x800000L, active1, 0x8000000000000000L, active2, 0L, active3, 0x40000000000L, active4, 0x800000L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0xc84881fff0000400L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active8 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(10, 558, 76); + return jjMoveStringLiteralDfa11_4(active0, 0x1000000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0x10000L, active8, 0x1100000000000000L, active9, 0x4000000000L, active10, 0L); + case 68: + case 100: + if ((active3 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(10, 216, 76); + else if ((active5 & 0x80L) != 0L) + return jjStartNfaWithStates_4(10, 327, 76); + else if ((active5 & 0x100L) != 0L) + return jjStartNfaWithStates_4(10, 328, 76); + else if ((active9 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 638, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x100000000L, active10, 0L); + case 69: + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(10, 39, 76); + else if ((active1 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(10, 88, 76); + else if ((active2 & 0x4L) != 0L) + return jjStartNfaWithStates_4(10, 130, 76); + else if ((active3 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(10, 207, 76); + else if ((active4 & 0x10L) != 0L) + return jjStartNfaWithStates_4(10, 260, 76); + else if ((active7 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(10, 487, 76); + else if ((active7 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 506, 76); + else if ((active9 & 0x400000L) != 0L) + return jjStartNfaWithStates_4(10, 598, 76); + else if ((active9 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(10, 602, 76); + else if ((active10 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 701, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0x1L, active3, 0L, active4, 0x1000000000000000L, active5, 0L, active6, 0x1000000000L, active7, 0x1000000000008000L, active8, 0x2000000000000000L, active9, 0L, active10, 0x800080000f000L); + case 70: + case 102: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active6 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 442, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_4(10, 66, 76); + else if ((active6 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(10, 403, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x1000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0x20000000000000L); + case 73: + case 105: + return jjMoveStringLiteralDfa11_4(active0, 0x10800000000L, active1, 0x200000001000L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xa00000000L, active10, 0L); + case 76: + case 108: + if ((active1 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(10, 94, 76); + else if ((active8 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(10, 536, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x400000000000010L, active2, 0L, active3, 0L, active4, 0x80L, active5, 0L, active6, 0L, active7, 0x100020000000000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa11_4(active0, 0x1000000000000000L, active1, 0x6000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x80010000000L, active8, 0L, active9, 0x10000000000000L, active10, 0L); + case 78: + case 110: + if ((active2 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(10, 159, 76); + else if ((active8 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(10, 532, 76); + else if ((active9 & 0x10000000000L) != 0L) + { + jjmatchedKind = 616; + jjmatchedPos = 10; + } + else if ((active9 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 624, 76); + else if ((active10 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 696, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x86100000L, active2, 0xc00000000180L, active3, 0L, active4, 0L, active5, 0x8L, active6, 0x8000400L, active7, 0L, active8, 0x602000000000000L, active9, 0x80000e0000000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x2000L, active9, 0x400000000L, active10, 0L); + case 80: + case 112: + if ((active9 & 0x80L) != 0L) + return jjStartNfaWithStates_4(10, 583, 76); + else if ((active10 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 694, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x800L, active9, 0L, active10, 0L); + case 81: + case 113: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active1 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(10, 104, 76); + else if ((active8 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(10, 539, 76); + else if ((active9 & 0x1L) != 0L) + return jjStartNfaWithStates_4(10, 576, 76); + else if ((active9 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(10, 599, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000000L, active9, 0x800000021000L, active10, 0L); + case 83: + case 115: + if ((active1 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_4(10, 103, 76); + else if ((active2 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(10, 162, 76); + else if ((active4 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(10, 280, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x2001e0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active4 & 0x2000000L) != 0L) + { + jjmatchedKind = 281; + jjmatchedPos = 10; + } + else if ((active8 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 564, 76); + else if ((active9 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(10, 589, 76); + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0x2c0000000000000L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0x10000004000000L, active5, 0x800000000010L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000000L, active9, 0L, active10, 0L); + case 87: + case 119: + if ((active1 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 123, 76); + break; + case 88: + case 120: + return jjMoveStringLiteralDfa11_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x20L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 54, 76); + else if ((active3 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 247, 76); + else if ((active8 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(10, 565, 76); + break; + default : + break; + } + return jjStartNfa_4(9, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa11_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(9, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 11; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active7 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(11, 491, 76); + return jjMoveStringLiteralDfa12_4(active0, 0x1000000L, active1, 0x140000000180000L, active2, 0L, active3, 0L, active4, 0x10000004000000L, active5, 0L, active6, 0x400L, active7, 0x8000000L, active8, 0L, active9, 0x8008000000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0x1006200000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x40040000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x100000000L) != 0L) + return jjStartNfaWithStates_4(11, 608, 76); + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 69: + case 101: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 60, 76); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 119, 76); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 122, 76); + else if ((active1 & 0x2000000000000000L) != 0L) + { + jjmatchedKind = 125; + jjmatchedPos = 11; + } + else if ((active4 & 0x80L) != 0L) + return jjStartNfaWithStates_4(11, 263, 76); + else if ((active7 & 0x10000000L) != 0L) + return jjStartNfaWithStates_4(11, 476, 76); + else if ((active7 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 504, 76); + else if ((active8 & 0x800L) != 0L) + return jjStartNfaWithStates_4(11, 523, 76); + else if ((active9 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 628, 76); + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0x50000000000000f0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0x4000000000000000L, active7, 0x20000000L, active8, 0L, active9, 0x20800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x200000000L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x800000L, active5, 0x8L, active6, 0x1000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active1 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 121, 76); + else if ((active5 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(11, 367, 76); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0x200000000L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x1000L, active10, 0L); + case 75: + case 107: + if ((active6 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(11, 411, 76); + else if ((active8 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 573, 76); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0x1fff0000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x8000000000400L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(11, 76, 76); + else if ((active4 & 0x800L) != 0L) + return jjStartNfaWithStates_4(11, 267, 76); + else if ((active8 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(11, 525, 76); + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0x8000202400000000L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0x8000L, active8, 0x80000000000L, active9, 0x800000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa12_4(active0, 0x800000000L, active1, 0L, active2, 0x100000000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x200L, active7, 0x20000000000L, active8, 0x1000000000000000L, active9, 0x4000000000L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active2 & 0x1L) != 0L) + return jjStartNfaWithStates_4(11, 128, 76); + else if ((active4 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 316, 76); + else if ((active7 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 508, 76); + else if ((active8 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(11, 559, 76); + else if ((active8 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 567, 76); + else if ((active8 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 574, 76); + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x8900000000000000L, active9, 0L, active10, 0x20000000000000L); + case 83: + case 115: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0xe0000000000L, active10, 0L); + case 84: + case 116: + if ((active3 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(11, 234, 76); + else if ((active5 & 0x20L) != 0L) + return jjStartNfaWithStates_4(11, 325, 76); + else if ((active8 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 561, 76); + else if ((active10 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(11, 675, 76); + return jjMoveStringLiteralDfa12_4(active0, 0x10000800000L, active1, 0x100L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x400000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa12_4(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x200000000000000L, active9, 0x400000000L, active10, 0L); + case 89: + case 121: + if ((active10 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(11, 691, 76); + break; + default : + break; + } + return jjStartNfa_4(10, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa12_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(10, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 12; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa13_4(active0, 0x800000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x4001fff0000000L, active9, 0xe0000000000L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x3400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active2 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(12, 161, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80000000000L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0xa00L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x400L) != 0L) + return jjStartNfaWithStates_4(12, 522, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0x1000007000L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + if ((active9 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(12, 609, 76); + break; + case 71: + case 103: + if ((active1 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_4(12, 109, 76); + else if ((active4 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(12, 279, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x4000000L, active5, 0L, active6, 0L, active7, 0x20000008000L, active8, 0L, active9, 0x800000021000L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_4(12, 570, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa13_4(active0, 0x10000000000L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 76: + case 108: + if ((active9 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(12, 639, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x1000000080100000L, active2, 0L, active3, 0L, active4, 0x10000000000000L, active5, 0L, active6, 0x400L, active7, 0x20000000L, active8, 0L, active9, 0x20000000000000L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(12, 35, 76); + else if ((active2 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(12, 184, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0L, active2, 0L, active3, 0x100000000000000L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x100000000000000L, active9, 0L, active10, 0x20000000000000L); + case 80: + case 112: + if ((active8 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(12, 563, 76); + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000000000000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 82: + case 114: + if ((active9 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(12, 610, 76); + return jjMoveStringLiteralDfa13_4(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0xc000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x60800e0L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0x18L, active6, 0L, active7, 0L, active8, 0xa00000000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa13_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x4800000000L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(12, 575, 76); + break; + default : + break; + } + return jjStartNfa_4(11, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa13_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(11, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 13; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0xe0L, active2, 0L, active3, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 124, 76); + else if ((active7 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(13, 477, 76); + else if ((active9 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 629, 76); + return jjMoveStringLiteralDfa14_4(active0, 0x800000L, active1, 0x80000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x40000000000L, active9, 0x20000000000L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x80000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x100L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 572, 76); + return jjMoveStringLiteralDfa14_4(active0, 0x1000000L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xf0000000L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x100000L) != 0L) + return jjStartNfaWithStates_4(13, 84, 76); + else if ((active6 & 0x200L) != 0L) + return jjStartNfaWithStates_4(13, 393, 76); + else if ((active6 & 0x400L) != 0L) + return jjStartNfaWithStates_4(13, 394, 76); + else if ((active8 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 569, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x200000L, active2, 0L, active3, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0x800000000000000L, active9, 0x800000020000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active4 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(13, 282, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x10L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x8L) != 0L) + return jjStartNfaWithStates_4(13, 323, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x4000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x80700000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x6000000L, active2, 0xc00000000000L, active3, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x1000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x2400000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active3 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 248, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x2000000L, active7, 0L, active8, 0x20000000000L, active9, 0x4000000000L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa14_4(active0, 0x10000000000L, active1, 0x40000000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x8000000L, active8, 0L, active9, 0x8000000000000L, active10, 0L); + case 80: + case 112: + if ((active4 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 308, 76); + break; + case 82: + case 114: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0L, active2, 0x180L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 83: + case 115: + if ((active7 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(13, 489, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0x4000000L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(13, 446, 76); + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x38000L, active8, 0L, active9, 0x800000000L, active10, 0xf000L); + case 88: + case 120: + if ((active6 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(13, 420, 76); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa14_4(active0, 0L, active1, 0L, active2, 0L, active3, 0L, active4, 0x2000000000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_4(12, active0, active1, active2, active3, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa14_4(long old0, long active0, long old1, long active1, long old2, long active2, long old3, long active3, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active3 &= old3) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(12, old0, old1, old2, old3, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 14; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x4000001000000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0xa00f0000000L, active9, 0L, active10, 0L); + case 67: + case 99: + if ((active6 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(14, 410, 76); + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x20L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(14, 98, 76); + else if ((active1 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(14, 101, 76); + else if ((active4 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_4(14, 317, 76); + else if ((active9 & 0x800000000L) != 0L) + return jjStartNfaWithStates_4(14, 611, 76); + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x4080000000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x14001c000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(14, 118, 76); + else if ((active7 & 0x8000000L) != 0L) + return jjStartNfaWithStates_4(14, 475, 76); + else if ((active9 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_4(14, 627, 76); + return jjMoveStringLiteralDfa15_4(active0, 0x800000L, active1, 0L, active2, 0L, active4, 0L, active5, 0x400000000000L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active7 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(14, 463, 76); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa15_4(active0, 0x1000000L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x80000L, active2, 0L, active4, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x200000L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(14, 40, 76); + else if ((active9 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(14, 588, 76); + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x40L, active2, 0L, active4, 0L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x8000000006000000L, active2, 0xc00000000000L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2700000000L, active9, 0xc0000000000L, active10, 0L); + case 82: + case 114: + if ((active8 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(14, 554, 76); + else if ((active8 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_4(14, 571, 76); + break; + case 83: + case 115: + if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_4(14, 72, 76); + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x80L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + if ((active6 & 0x2000000L) != 0L) + return jjStartNfaWithStates_4(14, 409, 76); + else if ((active9 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(14, 614, 76); + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0x100000000000010L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 86: + case 118: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0L, active2, 0x180L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active9 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(14, 593, 76); + else if ((active9 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(14, 623, 76); + break; + case 89: + case 121: + return jjMoveStringLiteralDfa15_4(active0, 0L, active1, 0L, active2, 0L, active4, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + default : + break; + } + return jjStartNfa_4(13, active0, active1, active2, 0L, active4, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa15_4(long old0, long active0, long old1, long active1, long old2, long active2, long old4, long active4, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active4 &= old4) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(13, old0, old1, old2, 0L, old4, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 15; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x200000L) != 0L) + return jjStartNfaWithStates_4(15, 85, 76); + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x60L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0x18000000000L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 69: + case 101: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0x400000000010L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 71: + case 103: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_4(15, 23, 76); + break; + case 72: + case 104: + if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_4(15, 68, 76); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x4000004000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 15; + } + else if ((active2 & 0x400000000000L) != 0L) + { + jjmatchedKind = 174; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_4(active0, 0x1000000L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0x3800000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x80000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0xf000L); + case 82: + case 114: + if ((active1 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(15, 95, 76); + else if ((active8 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(15, 555, 76); + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x20000000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x20000L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x700000000L, active9, 0L, active10, 0L); + case 89: + case 121: + if ((active8 & 0x10000000L) != 0L) + { + jjmatchedKind = 540; + jjmatchedPos = 15; + } + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 90: + case 122: + return jjMoveStringLiteralDfa16_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + default : + break; + } + return jjStartNfa_4(14, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa16_4(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(14, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 16; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(16, 102, 76); + return jjMoveStringLiteralDfa17_4(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 69: + case 101: + if ((active7 & 0x20000L) != 0L) + return jjStartNfaWithStates_4(16, 465, 76); + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0xf000L); + case 71: + case 103: + if ((active1 & 0x80000L) != 0L) + return jjStartNfaWithStates_4(16, 83, 76); + break; + case 72: + case 104: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0x4000L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0x8000000000000040L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0x1000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + if ((active1 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_4(16, 126, 76); + break; + case 82: + case 114: + if ((active8 & 0x100000000L) != 0L) + { + jjmatchedKind = 544; + jjmatchedPos = 16; + } + else if ((active8 & 0x8000000000L) != 0L) + { + jjmatchedKind = 551; + jjmatchedPos = 16; + } + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0x100000000000020L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x2000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa17_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1800000000L, active9, 0L, active10, 0L); + case 88: + case 120: + if ((active5 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_4(16, 366, 76); + break; + case 89: + case 121: + if ((active8 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(16, 553, 76); + break; + default : + break; + } + return jjStartNfa_4(15, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa17_4(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(15, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 17; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0x8000000000000000L, active2, 0x180L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0xf000L); + case 65: + case 97: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 69: + case 101: + if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_4(17, 70, 76); + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(17, 100, 76); + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active8 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_4(17, 549, 76); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x4000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa18_4(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0x140004000000000L, active9, 0L, active10, 0L); + case 82: + case 114: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x18e0000000L, active9, 0L, active10, 0x20000000000000L); + case 86: + case 118: + return jjMoveStringLiteralDfa18_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x20000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_4(16, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa18_4(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(16, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 18; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x7000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0x80L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x3000L); + case 68: + case 100: + if ((active8 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_4(18, 550, 76); + else if ((active8 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_4(18, 566, 76); + else if ((active8 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(18, 568, 76); + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active8 & 0x800000000L) != 0L) + { + jjmatchedKind = 547; + jjmatchedPos = 18; + } + else if ((active9 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_4(18, 617, 76); + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 71: + case 103: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa19_4(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 76: + case 108: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0x20L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0x80L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x4000L); + case 79: + case 111: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0xe0000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0x100L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 84: + case 116: + return jjMoveStringLiteralDfa19_4(active0, 0L, active1, 0L, active2, 0L, active5, 0x10L, active6, 0L, active7, 0x4000L, active8, 0x10600000000L, active9, 0x40000000000L, active10, 0L); + default : + break; + } + return jjStartNfa_4(17, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa19_4(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(17, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); + return 19; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0x10e0000000L, active9, 0x80000000000L, active10, 0L); + case 65: + case 97: + if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_4(19, 71, 76); + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x5000L); + case 67: + case 99: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x1000L, active7, 0L, active8, 0L, active9, 0L, active10, 0x8000L); + case 68: + case 100: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0x4000000L, active2, 0x800000000000L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + if ((active5 & 0x10L) != 0L) + return jjStartNfaWithStates_4(19, 324, 76); + break; + case 78: + case 110: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active5, 0L, active6, 0x2000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0x20L, active2, 0x80L, active5, 0L, active6, 0x800L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0x20000000002000L); + case 82: + case 114: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0x8000000000000000L, active2, 0x100L, active5, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa20_4(active0, 0L, active1, 0L, active2, 0L, active5, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa20_4(active0, 0x1000000L, active1, 0L, active2, 0L, active5, 0L, active6, 0L, active7, 0x10000L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 89: + case 121: + if ((active7 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(19, 462, 76); + break; + default : + break; + } + return jjStartNfa_4(18, active0, active1, active2, 0L, 0L, active5, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa20_4(long old0, long active0, long old1, long active1, long old2, long active2, long old5, long active5, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active5 &= old5) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(18, old0, old1, old2, 0L, 0L, old5, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); + return 20; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x10600000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0x3000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 66: + case 98: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0x80000000000L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0x4000L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0x80L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x2000L); + case 69: + case 101: + if ((active1 & 0x4000000L) != 0L) + return jjStartNfaWithStates_4(20, 90, 76); + else if ((active2 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_4(20, 175, 76); + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0x100L, active6, 0L, active7, 0L, active8, 0L, active9, 0x40000000000L, active10, 0L); + case 71: + case 103: + if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_4(20, 69, 76); + break; + case 72: + case 104: + if ((active7 & 0x10000L) != 0L) + return jjStartNfaWithStates_4(20, 464, 76); + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x20000000L, active9, 0L, active10, 0x8000L); + case 77: + case 109: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x40000000L, active9, 0L, active10, 0x4000L); + case 78: + case 110: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 79: + case 111: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0x8000000000000000L, active2, 0L, active6, 0L, active7, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0x100000000000000L, active2, 0L, active6, 0x800L, active7, 0L, active8, 0x80000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa21_4(active0, 0L, active1, 0L, active2, 0L, active6, 0L, active7, 0L, active8, 0x1000000000L, active9, 0L, active10, 0x1000L); + case 89: + case 121: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_4(20, 24, 76); + break; + default : + break; + } + return jjStartNfa_4(19, active0, active1, active2, 0L, 0L, 0L, active6, active7, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa21_4(long old0, long active0, long old1, long active1, long old2, long active2, long old6, long active6, long old7, long active7, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active7 &= old7) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(19, old0, old1, old2, 0L, 0L, 0L, old6, old7, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 21; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000000000L); + case 65: + case 97: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0x80000000000L, active10, 0x1000L); + case 67: + case 99: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 68: + case 100: + if ((active9 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_4(21, 618, 76); + break; + case 69: + case 101: + if ((active2 & 0x80L) != 0L) + return jjStartNfaWithStates_4(21, 135, 76); + else if ((active10 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(21, 653, 76); + else if ((active10 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(21, 654, 76); + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x8000L); + case 70: + case 102: + return jjMoveStringLiteralDfa22_4(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 72: + case 104: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0x800L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0x2000L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x1020000000L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa22_4(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa22_4(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_4(20, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa22_4(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(20, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 22; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 65: + case 97: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0x80000000000L, active10, 0L); + case 69: + case 101: + if ((active6 & 0x2000L) != 0L) + return jjStartNfaWithStates_4(22, 397, 76); + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x200000000L, active9, 0L, active10, 0L); + case 76: + case 108: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x1000L); + case 77: + case 109: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0x20000000008000L); + case 78: + case 110: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa23_4(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0x10000000000L, active9, 0L, active10, 0L); + case 80: + case 112: + return jjMoveStringLiteralDfa23_4(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa23_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x20000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_4(21, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa23_4(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(21, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); + return 23; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa24_4(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 65: + case 97: + if ((active10 & 0x8000L) != 0L) + return jjStartNfaWithStates_4(23, 655, 76); + break; + case 67: + case 99: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active9, 0L, active10, 0L); + case 73: + case 105: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0x800L, active8, 0L, active9, 0L, active10, 0L); + case 75: + case 107: + if ((active9 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_4(23, 619, 76); + break; + case 76: + case 108: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0x1000L, active8, 0L, active9, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0x4000L, active8, 0L, active9, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x10200000000L, active9, 0L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active9, 0L, active10, 0x20000000001000L); + case 82: + case 114: + if ((active8 & 0x20000000L) != 0L) + return jjStartNfaWithStates_4(23, 541, 76); + return jjMoveStringLiteralDfa24_4(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active9, 0L, active10, 0L); + case 83: + case 115: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0x100L, active6, 0L, active8, 0x1000000000L, active9, 0L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa24_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x40000000L, active9, 0L, active10, 0L); + default : + break; + } + return jjStartNfa_4(22, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, active9, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa24_4(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old9, long active9, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active9 &= old9) | (active10 &= old10)) == 0L) + return jjStartNfa_4(22, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, old9, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 24; + } + switch(curChar) + { + case 65: + case 97: + if ((active6 & 0x4000L) != 0L) + return jjStartNfaWithStates_4(24, 398, 76); + break; + case 68: + case 100: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0L, active8, 0L, active10, 0x20000000000000L); + case 69: + case 101: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 70: + case 102: + return jjMoveStringLiteralDfa25_4(active1, 0x8000000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 71: + case 103: + if ((active10 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(24, 652, 76); + break; + case 73: + case 105: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 77: + case 109: + return jjMoveStringLiteralDfa25_4(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x80000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0x1800L, active8, 0x400000000L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x10040000000L, active10, 0L); + case 85: + case 117: + return jjMoveStringLiteralDfa25_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_4(23, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa25_4(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_4(23, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); + return 25; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa26_4(active1, 0x100000000000000L, active2, 0L, active6, 0L, active8, 0L, active10, 0L); + case 67: + case 99: + return jjMoveStringLiteralDfa26_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x1000000000L, active10, 0L); + case 68: + case 100: + if ((active8 & 0x80000000L) != 0L) + return jjStartNfaWithStates_4(25, 543, 76); + break; + case 69: + case 101: + if ((active8 & 0x40000000L) != 0L) + return jjStartNfaWithStates_4(25, 542, 76); + else if ((active10 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_4(25, 693, 76); + break; + case 71: + case 103: + if ((active6 & 0x1000L) != 0L) + return jjStartNfaWithStates_4(25, 396, 76); + break; + case 72: + case 104: + if ((active8 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_4(25, 552, 76); + break; + case 78: + case 110: + if ((active6 & 0x800L) != 0L) + return jjStartNfaWithStates_4(25, 395, 76); + return jjMoveStringLiteralDfa26_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x400000000L, active10, 0L); + case 79: + case 111: + return jjMoveStringLiteralDfa26_4(active1, 0x8000000000000000L, active2, 0x100L, active6, 0L, active8, 0L, active10, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa26_4(active1, 0L, active2, 0L, active6, 0L, active8, 0x200000000L, active10, 0L); + default : + break; + } + return jjStartNfa_4(24, 0L, active1, active2, 0L, 0L, 0L, active6, 0L, active8, 0L, active10, 0L, 0L); +} +private final int jjMoveStringLiteralDfa26_4(long old1, long active1, long old2, long active2, long old6, long active6, long old8, long active8, long old10, long active10) +{ + if (((active1 &= old1) | (active2 &= old2) | (active6 &= old6) | (active8 &= old8) | (active10 &= old10)) == 0L) + return jjStartNfa_4(24, 0L, old1, old2, 0L, 0L, 0L, old6, 0L, old8, 0L, old10, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 26; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x400000000L) != 0L) + return jjStartNfaWithStates_4(26, 546, 76); + break; + case 69: + case 101: + if ((active8 & 0x200000000L) != 0L) + return jjStartNfaWithStates_4(26, 545, 76); + break; + case 71: + case 103: + return jjMoveStringLiteralDfa27_4(active1, 0x100000000000000L, active2, 0L, active8, 0L); + case 78: + case 110: + if ((active2 & 0x100L) != 0L) + return jjStartNfaWithStates_4(26, 136, 76); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa27_4(active1, 0L, active2, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa27_4(active1, 0x8000000000000000L, active2, 0L, active8, 0L); + default : + break; + } + return jjStartNfa_4(25, 0L, active1, active2, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa27_4(long old1, long active1, long old2, long active2, long old8, long active8) +{ + if (((active1 &= old1) | (active2 &= old2) | (active8 &= old8)) == 0L) + return jjStartNfa_4(25, 0L, old1, old2, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 27; + } + switch(curChar) + { + case 95: + return jjMoveStringLiteralDfa28_4(active1, 0x8000000000000000L, active8, 0L); + case 78: + case 110: + return jjMoveStringLiteralDfa28_4(active1, 0L, active8, 0x1000000000L); + case 82: + case 114: + return jjMoveStringLiteralDfa28_4(active1, 0x100000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_4(26, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa28_4(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_4(26, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); + return 28; + } + switch(curChar) + { + case 68: + case 100: + if ((active8 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_4(28, 548, 76); + break; + case 79: + case 111: + return jjMoveStringLiteralDfa29_4(active1, 0x100000000000000L, active8, 0L); + case 84: + case 116: + return jjMoveStringLiteralDfa29_4(active1, 0x8000000000000000L, active8, 0L); + default : + break; + } + return jjStartNfa_4(27, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, active8, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa29_4(long old1, long active1, long old8, long active8) +{ + if (((active1 &= old1) | (active8 &= old8)) == 0L) + return jjStartNfa_4(27, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, old8, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 29; + } + switch(curChar) + { + case 85: + case 117: + return jjMoveStringLiteralDfa30_4(active1, 0x100000000000000L); + case 89: + case 121: + return jjMoveStringLiteralDfa30_4(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_4(28, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa30_4(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_4(28, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 30; + } + switch(curChar) + { + case 80: + case 112: + if ((active1 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_4(30, 120, 76); + return jjMoveStringLiteralDfa31_4(active1, 0x8000000000000000L); + default : + break; + } + return jjStartNfa_4(29, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveStringLiteralDfa31_4(long old1, long active1) +{ + if (((active1 &= old1)) == 0L) + return jjStartNfa_4(29, 0L, old1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_4(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); + return 31; + } + switch(curChar) + { + case 69: + case 101: + if ((active1 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_4(31, 127, 76); + break; + default : + break; + } + return jjStartNfa_4(30, 0L, active1, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); +} +private final int jjMoveNfa_4(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 76; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + if ((0xfffffffbffffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + else if (curChar == 34) + { + if (kind > 724) + kind = 724; + } + break; + case 58: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + else if (curChar == 39) + { + if (kind > 725) + kind = 725; + } + if ((0xfc00f7faffffc9ffL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 1: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + else if (curChar == 39) + jjCheckNAddStates(15, 17); + if ((0x3ff201000000000L & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if (curChar == 36) + jjCheckNAdd(27); + break; + case 77: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 715) + kind = 715; + jjCheckNAdd(52); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(51, 41); + break; + case 78: + if (curChar == 32) + jjCheckNAddTwoStates(68, 69); + if (curChar == 32) + jjCheckNAddTwoStates(65, 66); + if (curChar == 32) + jjCheckNAddTwoStates(63, 64); + if (curChar == 32) + jjCheckNAddTwoStates(61, 62); + break; + case 31: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + else if (curChar == 38) + jjstateSet[jjnewStateCnt++] = 32; + if ((0x3ff201000000000L & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if (curChar == 36) + jjCheckNAdd(27); + break; + case 76: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x3ff201000000000L & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + if (curChar == 36) + jjCheckNAdd(27); + break; + case 74: + if (curChar == 47) + { + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + } + else if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 72; + break; + case 80: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x3ff201000000000L & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (curChar == 36) + jjCheckNAdd(27); + break; + case 0: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + else if (curChar == 47) + jjAddStates(70, 71); + else if (curChar == 39) + jjCheckNAddStates(72, 75); + else if (curChar == 46) + jjCheckNAddTwoStates(51, 52); + else if (curChar == 7) + { + if (kind > 786) + kind = 786; + } + else if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 11; + else if (curChar == 34) + jjCheckNAddStates(58, 60); + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 713) + kind = 713; + jjCheckNAddStates(76, 82); + } + else if (curChar == 36) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + break; + case 2: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(15, 17); + break; + case 3: + if (curChar == 39) + jjCheckNAddStates(15, 17); + break; + case 4: + if (curChar == 39) + jjstateSet[jjnewStateCnt++] = 3; + break; + case 5: + if (curChar == 39 && kind > 719) + kind = 719; + break; + case 6: + if (curChar == 34) + jjCheckNAddStates(58, 60); + break; + case 7: + if ((0xfffffffbffffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + break; + case 9: + jjCheckNAddStates(58, 60); + break; + case 10: + if (curChar == 34 && kind > 724) + kind = 724; + break; + case 11: + if (curChar != 45) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + case 12: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + case 13: + if ((0x2400L & l) != 0L && kind > 772) + kind = 772; + break; + case 14: + if (curChar == 10 && kind > 772) + kind = 772; + break; + case 15: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 14; + break; + case 16: + if (curChar == 45) + jjstateSet[jjnewStateCnt++] = 11; + break; + case 18: + case 20: + jjCheckNAddStates(83, 85); + break; + case 22: + if (curChar != 36) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 23: + if ((0x3ff201000000000L & l) == 0L) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 24: + if ((0x3ff001000000000L & l) != 0L) + jjCheckNAddStates(64, 66); + break; + case 25: + if ((0x7ff601000000000L & l) != 0L) + jjCheckNAddTwoStates(25, 26); + break; + case 26: + if (curChar == 36) + jjCheckNAdd(27); + break; + case 27: + if (curChar != 36) + break; + if (kind > 782) + kind = 782; + jjCheckNAddTwoStates(27, 28); + break; + case 28: + if (curChar == 36) + jjCheckNAdd(29); + break; + case 29: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjCheckNAdd(29); + break; + case 32: + if (curChar == 34) + jjCheckNAddTwoStates(33, 35); + break; + case 33: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(86, 88); + break; + case 34: + if (curChar == 34) + jjCheckNAddStates(86, 88); + break; + case 35: + if (curChar == 34) + jjstateSet[jjnewStateCnt++] = 34; + break; + case 36: + if (curChar == 34 && kind > 783) + kind = 783; + break; + case 37: + if (curChar == 7 && kind > 786) + kind = 786; + break; + case 38: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAddStates(76, 82); + break; + case 39: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 713) + kind = 713; + jjCheckNAdd(39); + break; + case 40: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(40, 41); + break; + case 42: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(43); + break; + case 43: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 714) + kind = 714; + jjCheckNAdd(43); + break; + case 44: + if (curChar == 46) + jjCheckNAddTwoStates(45, 41); + break; + case 45: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(45, 41); + break; + case 46: + if (curChar != 46) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(47); + break; + case 47: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(47); + break; + case 48: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAddStates(89, 91); + break; + case 49: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(92, 95); + break; + case 50: + if (curChar == 46) + jjCheckNAddTwoStates(51, 52); + break; + case 51: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(51, 41); + break; + case 52: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 715) + kind = 715; + jjCheckNAdd(52); + break; + case 53: + if (curChar == 39) + jjCheckNAddStates(72, 75); + break; + case 54: + if ((0xffffff7fffffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + break; + case 56: + jjCheckNAddStates(61, 63); + break; + case 57: + if (curChar == 39 && kind > 725) + kind = 725; + break; + case 59: + if (curChar == 39 && kind > 726) + kind = 726; + break; + case 61: + if (curChar == 32) + jjCheckNAddTwoStates(61, 62); + break; + case 63: + if (curChar == 32) + jjCheckNAddTwoStates(63, 64); + break; + case 65: + if (curChar == 32) + jjCheckNAddTwoStates(65, 66); + break; + case 68: + if (curChar == 32) + jjCheckNAddTwoStates(68, 69); + break; + case 71: + if (curChar == 47) + jjAddStates(70, 71); + break; + case 72: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 73; + break; + case 73: + if ((0xffff7fffffffffffL & l) != 0L && kind > 770) + kind = 770; + break; + case 75: + if (curChar != 47) + break; + if (kind > 772) + kind = 772; + jjCheckNAddStates(67, 69); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 9; + break; + case 58: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 56; + if ((0xffffff81ffffff81L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 1: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + break; + case 78: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 70; + else if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 67; + else if ((0x1000000010L & l) != 0L) + { + if (kind > 729) + kind = 729; + } + if ((0x10000000100000L & l) != 0L) + { + if (kind > 730) + kind = 730; + } + break; + case 31: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + break; + case 76: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + break; + case 80: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + else if (curChar == 123) + jjAddStates(96, 103); + else if (curChar == 96) + jjCheckNAddStates(83, 85); + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if ((0x20000000200000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 31; + else if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 2: + jjAddStates(15, 17); + break; + case 7: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(58, 60); + break; + case 8: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 9; + break; + case 9: + jjCheckNAddStates(58, 60); + break; + case 12: + if (kind > 772) + kind = 772; + jjAddStates(67, 69); + break; + case 17: + if (curChar == 96) + jjCheckNAddStates(83, 85); + break; + case 18: + if ((0xfffffffeefffffffL & l) != 0L) + jjCheckNAddStates(83, 85); + break; + case 19: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 20; + break; + case 20: + jjCheckNAddStates(83, 85); + break; + case 21: + if (curChar == 96 && kind > 779) + kind = 779; + break; + case 22: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 23: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 24: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddStates(64, 66); + break; + case 25: + if ((0x7fffffe87fffffeL & l) != 0L) + jjCheckNAddTwoStates(25, 26); + break; + case 27: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjAddStates(104, 105); + break; + case 29: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 29; + break; + case 30: + if ((0x20000000200000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 31; + break; + case 33: + jjAddStates(86, 88); + break; + case 41: + if ((0x2000000020L & l) != 0L) + jjAddStates(106, 107); + break; + case 54: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(61, 63); + break; + case 55: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 56; + break; + case 56: + jjCheckNAddStates(61, 63); + break; + case 60: + if (curChar == 123) + jjAddStates(96, 103); + break; + case 62: + if ((0x1000000010L & l) != 0L && kind > 729) + kind = 729; + break; + case 64: + if ((0x10000000100000L & l) != 0L && kind > 730) + kind = 730; + break; + case 66: + if ((0x10000000100000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 67; + break; + case 67: + if ((0x8000000080000L & l) != 0L && kind > 731) + kind = 731; + break; + case 69: + if ((0x4000000040L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 70; + break; + case 70: + if ((0x400000004000L & l) != 0L && kind > 732) + kind = 732; + break; + case 73: + if (kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 79: + case 7: + case 9: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(58, 60); + break; + case 58: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(61, 63); + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 1: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 31: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 76: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 80: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 0: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + } + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + break; + case 2: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(15, 17); + break; + case 12: + if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) + break; + if (kind > 772) + kind = 772; + jjAddStates(67, 69); + break; + case 18: + case 20: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(83, 85); + break; + case 22: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 23: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 780) + kind = 780; + jjCheckNAdd(23); + break; + case 24: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(64, 66); + break; + case 25: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjCheckNAddTwoStates(25, 26); + break; + case 27: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjAddStates(104, 105); + break; + case 29: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 782) + kind = 782; + jjstateSet[jjnewStateCnt++] = 29; + break; + case 33: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(86, 88); + break; + case 54: + case 56: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjCheckNAddStates(61, 63); + break; + case 73: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 770) + kind = 770; + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 76 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +static final int[] jjnextStates = { + 28, 29, 30, 10, 12, 13, 22, 24, 25, 16, 17, 19, 51, 53, 54, 2, + 4, 5, 84, 85, 51, 53, 54, 55, 36, 37, 41, 38, 43, 45, 46, 43, + 44, 45, 41, 42, 38, 46, 60, 62, 63, 66, 68, 69, 71, 72, 73, 74, + 75, 76, 78, 79, 58, 64, 31, 32, 39, 40, 7, 8, 10, 54, 55, 57, + 24, 25, 26, 12, 13, 15, 74, 75, 54, 55, 57, 58, 39, 40, 44, 41, + 46, 48, 49, 18, 19, 21, 33, 35, 36, 46, 47, 48, 44, 45, 41, 49, + 61, 62, 63, 64, 65, 66, 68, 69, 27, 28, 42, 43, +}; +private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec2[i2] & l2) != 0L); + default : + if ((jjbitVec0[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec4[i2] & l2) != 0L); + case 45: + return ((jjbitVec5[i2] & l2) != 0L); + case 48: + return ((jjbitVec6[i2] & l2) != 0L); + case 49: + return ((jjbitVec7[i2] & l2) != 0L); + case 51: + return ((jjbitVec8[i2] & l2) != 0L); + case 61: + return ((jjbitVec9[i2] & l2) != 0L); + default : + if ((jjbitVec3[i1] & l1) != 0L) + return true; + return false; + } +} +public static final String[] jjstrLiteralImages = { +"", "\41", "\176", null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +"\50", "\51", null, null, null, null, "\173", "\175", "\133", "\135", "\73", "\56", +"\54", "\75", "\76", "\74", "\77", "\72", "\74\75", "\76\75", "\74\76", "\41\75", +"\53", "\55", "\52", "\57", "\45", "\174\174", "\75\76", "\56\56", "\47", "\42", +"\174", "\136", "\44", "\72\72", null, null, null, null, null, "\57\52\53", "\52\57", +null, null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, }; +public static final String[] lexStateNames = { + "DEFAULT", + "DQID", + "BTID", + "BQID", + "BQHID", + "IN_FORMAL_COMMENT", + "IN_MULTI_LINE_COMMENT", +}; +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, 6, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; +static final long[] jjtoToken = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x7fffffffff78fffL, + 0x4ff03L, +}; +static final long[] jjtoSkip = { + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0xf800000000000000L, + 0x70L, +}; +static final long[] jjtoSpecial = { + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0x0L, + 0x60L, +}; +static final long[] jjtoMore = { + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0x0L, + 0x0L, 0x0L, 0x0L, 0x0L, + 0x8cL, +}; +protected SimpleCharStream input_stream; +private final int[] jjrounds = new int[86]; +private final int[] jjstateSet = new int[172]; +StringBuffer image; +int jjimageLen; +int lengthOfMatch; +protected char curChar; +public IgniteSqlParserImplTokenManager(SimpleCharStream stream){ + if (SimpleCharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} +public IgniteSqlParserImplTokenManager(SimpleCharStream stream, int lexState){ + this(stream); + SwitchTo(lexState); +} +public void ReInit(SimpleCharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private final void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 86; i-- > 0;) + jjrounds[i] = 0x80000000; +} +public void ReInit(SimpleCharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} +public void SwitchTo(int lexState) +{ + if (lexState >= 7 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +protected Token jjFillToken() +{ + Token t = Token.newToken(jjmatchedKind); + t.kind = jjmatchedKind; + String im = jjstrLiteralImages[jjmatchedKind]; + t.image = (im == null) ? input_stream.GetImage() : im; + t.beginLine = input_stream.getBeginLine(); + t.beginColumn = input_stream.getBeginColumn(); + t.endLine = input_stream.getEndLine(); + t.endColumn = input_stream.getEndColumn(); + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +public Token getNextToken() +{ + int kind; + Token specialToken = null; + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + return matchedToken; + } + image = null; + jjimageLen = 0; + + for (;;) + { + switch(curLexState) + { + case 0: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + break; + case 2: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_2(); + break; + case 3: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_3(); + break; + case 4: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_4(); + break; + case 5: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_5(); + if (jjmatchedPos == 0 && jjmatchedKind > 775) + { + jjmatchedKind = 775; + } + break; + case 6: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_6(); + if (jjmatchedPos == 0 && jjmatchedKind > 775) + { + jjmatchedKind = 775; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + TokenLexicalActions(matchedToken); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (specialToken == null) + specialToken = matchedToken; + else + { + matchedToken.specialToken = specialToken; + specialToken = (specialToken.next = matchedToken); + } + SkipLexicalActions(matchedToken); + } + else + SkipLexicalActions(null); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + MoreLexicalActions(); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } + } +} + +void SkipLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + case 773 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + popState(); + break; + case 774 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + popState(); + break; + default : + break; + } +} +void MoreLexicalActions() +{ + jjimageLen += (lengthOfMatch = jjmatchedPos + 1); + switch(jjmatchedKind) + { + case 770 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen)); + jjimageLen = 0; + pushState(); + break; + case 771 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen)); + jjimageLen = 0; + pushState(); + break; + default : + break; + } +} +void TokenLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + case 152 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 158 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 219 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 261 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 276 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 322 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 499 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + afterTableName(); + break; + case 509 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + afterTableName(); + break; + case 600 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 647 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + beforeTableName(); + break; + case 661 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + afterTableName(); + break; + case 780 : + if (image == null) + image = new StringBuffer(); + image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); + popState(); + break; + default : + break; + } +} +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/ParseException.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/ParseException.java new file mode 100644 index 0000000000000..f681bffe45265 --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/ParseException.java @@ -0,0 +1,192 @@ +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends Exception { + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. The boolean + * flag "specialConstructor" is also set to true to indicate that + * this constructor was used to create this object. + * This constructor calls its super class with the empty string + * to force the "toString" method of parent class "Throwable" to + * print the error message in the form: + * ParseException: + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) + { + super(""); + specialConstructor = true; + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + specialConstructor = false; + } + + public ParseException(String message) { + super(message); + specialConstructor = false; + } + + /** + * This variable determines which constructor was used to create + * this object and thereby affects the semantics of the + * "getMessage" method (see below). + */ + protected boolean specialConstructor; + + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + + /** + * This method has the standard behavior when this object has been + * created using the standard constructors. Otherwise, it uses + * "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser), then this method is called during the printing + * of the final stack trace, and hence the correct error message + * gets displayed. + */ + public String getMessage() { + if (!specialConstructor) { + return super.getMessage(); + } + StringBuffer expected = new StringBuffer(); + int maxSize = 0; + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + expected.append(tokenImage[expectedTokenSequences[i][j]]).append(" "); + } + if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + expected.append(eol).append(" "); + } + String retval = "Encountered \""; + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + if (i != 0) retval += " "; + if (tok.kind == 0) { + retval += tokenImage[0]; + break; + } + retval += add_escapes(tok.image); + tok = tok.next; + } + retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; + retval += "." + eol; + if (expectedTokenSequences.length == 1) { + retval += "Was expecting:" + eol + " "; + } else { + retval += "Was expecting one of:" + eol + " "; + } + retval += expected.toString(); + return retval; + } + + /** + * The end of line string for this machine. + */ + protected String eol = System.getProperty("line.separator", "\n"); + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + protected String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/SimpleCharStream.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/SimpleCharStream.java new file mode 100644 index 0000000000000..91ec3d3c6427f --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/SimpleCharStream.java @@ -0,0 +1,439 @@ +/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 4.0 */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (without unicode processing). + */ + +public class SimpleCharStream +{ + public static final boolean staticFlag = false; + int bufsize; + int available; + int tokenBegin; + public int bufpos = -1; + protected int bufline[]; + protected int bufcolumn[]; + + protected int column = 0; + protected int line = 1; + + protected boolean prevCharIsCR = false; + protected boolean prevCharIsLF = false; + + protected java.io.Reader inputStream; + + protected char[] buffer; + protected int maxNextCharInd = 0; + protected int inBuf = 0; + protected int tabSize = 8; + + protected void setTabSize(int i) { tabSize = i; } + protected int getTabSize(int i) { return tabSize; } + + + protected void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, + bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos += (bufsize - tokenBegin)); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos -= tokenBegin); + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + + bufsize += 2048; + available = bufsize; + tokenBegin = 0; + } + + protected void FillBuff() throws java.io.IOException + { + if (maxNextCharInd == available) + { + if (available == bufsize) + { + if (tokenBegin > 2048) + { + bufpos = maxNextCharInd = 0; + available = tokenBegin; + } + else if (tokenBegin < 0) + bufpos = maxNextCharInd = 0; + else + ExpandBuff(false); + } + else if (available > tokenBegin) + available = bufsize; + else if ((tokenBegin - available) < 2048) + ExpandBuff(true); + else + available = tokenBegin; + } + + int i; + try { + if ((i = inputStream.read(buffer, maxNextCharInd, + available - maxNextCharInd)) == -1) + { + inputStream.close(); + throw new java.io.IOException(); + } + else + maxNextCharInd += i; + return; + } + catch(java.io.IOException e) { + --bufpos; + backup(0); + if (tokenBegin == -1) + tokenBegin = bufpos; + throw e; + } + } + + public char BeginToken() throws java.io.IOException + { + tokenBegin = -1; + char c = readChar(); + tokenBegin = bufpos; + + return c; + } + + protected void UpdateLineColumn(char c) + { + column++; + + if (prevCharIsLF) + { + prevCharIsLF = false; + line += (column = 1); + } + else if (prevCharIsCR) + { + prevCharIsCR = false; + if (c == '\n') + { + prevCharIsLF = true; + } + else + line += (column = 1); + } + + switch (c) + { + case '\r' : + prevCharIsCR = true; + break; + case '\n' : + prevCharIsLF = true; + break; + case '\t' : + column--; + column += (tabSize - (column % tabSize)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + + public char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + return buffer[bufpos]; + } + + if (++bufpos >= maxNextCharInd) + FillBuff(); + + char c = buffer[bufpos]; + + UpdateLineColumn(c); + return (c); + } + + /** + * @deprecated + * @see #getEndColumn + */ + + public int getColumn() { + return bufcolumn[bufpos]; + } + + /** + * @deprecated + * @see #getEndLine + */ + + public int getLine() { + return bufline[bufpos]; + } + + public int getEndColumn() { + return bufcolumn[bufpos]; + } + + public int getEndLine() { + return bufline[bufpos]; + } + + public int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + public int getBeginLine() { + return bufline[tokenBegin]; + } + + public void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + public SimpleCharStream(java.io.Reader dstream) + { + this(dstream, 1, 1, 4096); + } + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + bufpos = -1; + } + + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + public void ReInit(java.io.Reader dstream) + { + ReInit(dstream, 1, 1, 4096); + } + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, startline, startcolumn, 4096); + } + + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, 1, 1, 4096); + } + + public SimpleCharStream(java.io.InputStream dstream) + { + this(dstream, 1, 1, 4096); + } + + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, 1, 1, 4096); + } + + public void ReInit(java.io.InputStream dstream) + { + ReInit(dstream, 1, 1, 4096); + } + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, startline, startcolumn, 4096); + } + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + public String GetImage() + { + if (bufpos >= tokenBegin) + return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); + else + return new String(buffer, tokenBegin, bufsize - tokenBegin) + + new String(buffer, 0, bufpos + 1); + } + + public char[] GetSuffix(int len) + { + char[] ret = new char[len]; + + if ((bufpos + 1) >= len) + System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); + else + { + System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, + len - bufpos - 1); + System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); + } + + return ret; + } + + public void Done() + { + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token. + */ + public void adjustBeginLineColumn(int newLine, int newCol) + { + int start = tokenBegin; + int len; + + if (bufpos >= tokenBegin) + { + len = bufpos - tokenBegin + inBuf + 1; + } + else + { + len = bufsize - tokenBegin + bufpos + 1 + inBuf; + } + + int i = 0, j = 0, k = 0; + int nextColDiff = 0, columnDiff = 0; + + while (i < len && + bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) + { + bufline[j] = newLine; + nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; + bufcolumn[j] = newCol + columnDiff; + columnDiff = nextColDiff; + i++; + } + + if (i < len) + { + bufline[j] = newLine++; + bufcolumn[j] = newCol + columnDiff; + + while (i++ < len) + { + if (bufline[j = start % bufsize] != bufline[++start % bufsize]) + bufline[j] = newLine++; + else + bufline[j] = newLine; + } + } + + line = bufline[j]; + column = bufcolumn[j]; + } + +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/Token.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/Token.java new file mode 100644 index 0000000000000..c541462a0a11e --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/Token.java @@ -0,0 +1,81 @@ +/* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +/** + * Describes the input token stream. + */ + +public class Token { + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** + * beginLine and beginColumn describe the position of the first character + * of this token; endLine and endColumn describe the position of the + * last character of this token. + */ + public int beginLine, beginColumn, endLine, endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * Returns the image. + */ + public String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simlpy add something like : + * + * case MyParserConstants.ID : return new IDToken(); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use it in your lexical actions. + */ + public static final Token newToken(int ofKind) + { + switch(ofKind) + { + default : return new Token(); + } + } + +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/TokenMgrError.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/TokenMgrError.java new file mode 100644 index 0000000000000..e8862d5495877 --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/TokenMgrError.java @@ -0,0 +1,133 @@ +/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */ +package org.apache.ignite.internal.processors.query.calcite.sql.generated; + +public class TokenMgrError extends Error +{ + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occured. + */ + static final int LEXICAL_ERROR = 0; + + /** + * An attempt wass made to create a second instance of a static token manager. + */ + static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their espaced (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexicl error + * curLexState : lexical state in which this error occured + * errorLine : line number when the error occured + * errorColumn : column number when the error occured + * errorAfter : prefix that was seen before this error occured + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? " " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + public TokenMgrError() { + } + + public TokenMgrError(String message, int reason) { + super(message); + errorCode = reason; + } + + public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { + this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/package-info.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/package-info.java new file mode 100644 index 0000000000000..c85c002a1a782 --- /dev/null +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/package-info.java @@ -0,0 +1,28 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Contains generated parser files. + * + * WARNING: Do not modify files in this package manually. + * + * To regenerate classes use command: + * + * mvn generate-sources -pl :ignite-calcite + */ + +package org.apache.ignite.internal.processors.query.calcite.sql.generated; diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/sql/SqlCustomParserTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/sql/SqlCustomParserTest.java index 43d1babd662ff..a101da14188c1 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/sql/SqlCustomParserTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/sql/SqlCustomParserTest.java @@ -34,6 +34,7 @@ import org.apache.calcite.sql.parser.SqlParseException; import org.apache.calcite.sql.parser.SqlParser; import org.apache.calcite.sql.validate.SqlValidatorException; +import org.apache.ignite.internal.processors.query.calcite.sql.generated.IgniteSqlParserImpl; import org.apache.ignite.internal.processors.query.calcite.sql.kill.IgniteSqlKillComputeTask; import org.apache.ignite.internal.processors.query.calcite.sql.kill.IgniteSqlKillContinuousQuery; import org.apache.ignite.internal.processors.query.calcite.sql.kill.IgniteSqlKillQuery; diff --git a/parent/pom.xml b/parent/pom.xml index 4b3ecce915384..4b9cd6db98944 100644 --- a/parent/pom.xml +++ b/parent/pom.xml @@ -913,6 +913,7 @@ src/main/java/org/apache/ignite/internal/util/offheap/unsafe/GridOffHeapSnapTreeMap.java src/main/java/org/apache/ignite/internal/util/nio/SelectedSelectionKeySet.java src/main/java/org/apache/ignite/internal/util/snaptree/*.java + src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/*.java src/main/java/org/jsr166/*.java src/main/java/org/mindrot/*.java src/test/java/org/apache/ignite/p2p/p2p.properties