com.github._1c_syntax.bsl.parser.SDBLParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bsl-parser Show documentation
Collection of parsers for Language 1C (BSL) in ANTLR4 format.
The newest version!
// Generated from SDBLParser.g4 by ANTLR 4.13.1
package com.github._1c_syntax.bsl.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class SDBLParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		WHITE_SPACE=1, LINE_COMMENT=2, DOT=3, LPAREN=4, RPAREN=5, SEMICOLON=6, 
		COMMA=7, ASSIGN=8, PLUS=9, MINUS=10, LESS_OR_EQUAL=11, NOT_EQUAL=12, LESS=13, 
		GREATER_OR_EQUAL=14, GREATER=15, MUL=16, QUOTIENT=17, AMPERSAND=18, BRACE=19, 
		ALLOWED=20, AND=21, AS=22, ASC=23, AUTOORDER=24, BETWEEN=25, BY_EN=26, 
		CASE=27, CAST=28, DESC=29, DISTINCT=30, DROP=31, ELSE=32, END=33, ESCAPE=34, 
		FALSE=35, FROM=36, HAVING=37, HIERARCHY=38, INTO=39, IS=40, ISNULL=41, 
		LIKE=42, NOT=43, NULL=44, OF=45, ON_EN=46, OR=47, OVERALL=48, PO_RU=49, 
		SELECT=50, THEN=51, TOP=52, TOTALS=53, TRUE=54, UNDEFINED=55, WHEN=56, 
		WHERE=57, ACOS=58, ASIN=59, ATAN=60, AVG=61, BEGINOFPERIOD=62, BOOLEAN=63, 
		COS=64, COUNT=65, DATE=66, DATEADD=67, DATEDIFF=68, DATETIME=69, DAY=70, 
		DAYOFYEAR=71, EMPTYTABLE=72, EMPTYREF=73, ENDOFPERIOD=74, EXP=75, HALFYEAR=76, 
		HOUR=77, INT=78, LOG=79, LOG10=80, LOWER=81, MAX=82, MIN=83, MINUTE=84, 
		MONTH=85, NUMBER=86, QUARTER=87, ONLY=88, PERIODS=89, REFS=90, PRESENTATION=91, 
		RECORDAUTONUMBER=92, REFPRESENTATION=93, POW=94, ROUND=95, SECOND=96, 
		SIN=97, SQRT=98, STOREDDATASIZE=99, STRING=100, STRINGLENGTH=101, STRFIND=102, 
		STRREPLACE=103, SUBSTRING=104, SUM=105, TAN=106, TENDAYS=107, TRIMALL=108, 
		TRIML=109, TRIMR=110, TYPE=111, UPPER=112, VALUE=113, VALUETYPE=114, WEEK=115, 
		WEEKDAY=116, YEAR=117, UUID=118, ACCOUNTING_REGISTER_TYPE=119, ACCUMULATION_REGISTER_TYPE=120, 
		BUSINESS_PROCESS_TYPE=121, CALCULATION_REGISTER_TYPE=122, CATALOG_TYPE=123, 
		CHART_OF_ACCOUNTS_TYPE=124, CHART_OF_CALCULATION_TYPES_TYPE=125, CHART_OF_CHARACTERISTIC_TYPES_TYPE=126, 
		CONSTANT_TYPE=127, DOCUMENT_TYPE=128, DOCUMENT_JOURNAL_TYPE=129, ENUM_TYPE=130, 
		EXCHANGE_PLAN_TYPE=131, EXTERNAL_DATA_SOURCE_TYPE=132, FILTER_CRITERION_TYPE=133, 
		INFORMATION_REGISTER_TYPE=134, SEQUENCE_TYPE=135, TASK_TYPE=136, ROUTEPOINT_FIELD=137, 
		INDEX=138, GROUP=139, ORDER=140, GROUPEDBY=141, GROUPING=142, SET=143, 
		RIGHT=144, LEFT=145, INNER=146, FULL=147, JOIN=148, OUTER=149, FOR=150, 
		UPDATE=151, ALL=152, UNION=153, HIERARCHY_FOR_IN=154, IN=155, DECIMAL=156, 
		FLOAT=157, STR=158, INCORRECT_IDENTIFIER=159, IDENTIFIER=160, UNKNOWN=161, 
		PARAMETER_IDENTIFIER=162, ACTUAL_ACTION_PERIOD_VT=163, BALANCE_VT=164, 
		BALANCE_AND_TURNOVERS_VT=165, BOUNDARIES_VT=166, DR_CR_TURNOVERS_VT=167, 
		EXT_DIMENSIONS_VT=168, RECORDS_WITH_EXT_DIMENSIONS_VT=169, SCHEDULE_DATA_VT=170, 
		SLICEFIRST_VT=171, SLICELAST_VT=172, TASK_BY_PERFORMER_VT=173, TURNOVERS_VT=174, 
		BRACE_IDENTIFIER=175, BRACE_START=176, EDS_TABLE=177, EDS_CUBE=178, EDS_CUBE_DIMTABLE=179;
	public static final int
		RULE_queryPackage = 0, RULE_queries = 1, RULE_dropTableQuery = 2, RULE_selectQuery = 3, 
		RULE_subquery = 4, RULE_union = 5, RULE_query = 6, RULE_limitations = 7, 
		RULE_top = 8, RULE_selectedFields = 9, RULE_selectedField = 10, RULE_asteriskField = 11, 
		RULE_expressionField = 12, RULE_columnField = 13, RULE_emptyTableField = 14, 
		RULE_emptyTableColumns = 15, RULE_inlineTableField = 16, RULE_recordAutoNumberFunction = 17, 
		RULE_groupByItem = 18, RULE_indexingItem = 19, RULE_orderBy = 20, RULE_ordersByExpession = 21, 
		RULE_totalBy = 22, RULE_totalsGroup = 23, RULE_periodic = 24, RULE_column = 25, 
		RULE_expression = 26, RULE_primitiveExpression = 27, RULE_caseExpression = 28, 
		RULE_caseBranch = 29, RULE_bracketExpression = 30, RULE_unaryExpression = 31, 
		RULE_functionCall = 32, RULE_builtInFunctions = 33, RULE_aggregateFunctions = 34, 
		RULE_valueFunction = 35, RULE_castFunction = 36, RULE_logicalExpression = 37, 
		RULE_predicate = 38, RULE_likePredicate = 39, RULE_isNullPredicate = 40, 
		RULE_comparePredicate = 41, RULE_betweenPredicate = 42, RULE_inPredicate = 43, 
		RULE_refsPredicate = 44, RULE_expressionList = 45, RULE_dataSources = 46, 
		RULE_dataSource = 47, RULE_table = 48, RULE_virtualTable = 49, RULE_virtualTableParameter = 50, 
		RULE_parameterTable = 51, RULE_externalDataSourceTable = 52, RULE_joinPart = 53, 
		RULE_alias = 54, RULE_datePart = 55, RULE_multiString = 56, RULE_sign = 57, 
		RULE_identifier = 58, RULE_parameter = 59, RULE_mdo = 60;
	private static String[] makeRuleNames() {
		return new String[] {
			"queryPackage", "queries", "dropTableQuery", "selectQuery", "subquery", 
			"union", "query", "limitations", "top", "selectedFields", "selectedField", 
			"asteriskField", "expressionField", "columnField", "emptyTableField", 
			"emptyTableColumns", "inlineTableField", "recordAutoNumberFunction", 
			"groupByItem", "indexingItem", "orderBy", "ordersByExpession", "totalBy", 
			"totalsGroup", "periodic", "column", "expression", "primitiveExpression", 
			"caseExpression", "caseBranch", "bracketExpression", "unaryExpression", 
			"functionCall", "builtInFunctions", "aggregateFunctions", "valueFunction", 
			"castFunction", "logicalExpression", "predicate", "likePredicate", "isNullPredicate", 
			"comparePredicate", "betweenPredicate", "inPredicate", "refsPredicate", 
			"expressionList", "dataSources", "dataSource", "table", "virtualTable", 
			"virtualTableParameter", "parameterTable", "externalDataSourceTable", 
			"joinPart", "alias", "datePart", "multiString", "sign", "identifier", 
			"parameter", "mdo"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, null, "'.'", "'('", "')'", "';'", "','", "'='", "'+'", "'-'", 
			"'<='", "'<>'", "'<'", "'>='", "'>'", "'*'", "'/'", "'&'", null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, "'\"'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "WHITE_SPACE", "LINE_COMMENT", "DOT", "LPAREN", "RPAREN", "SEMICOLON", 
			"COMMA", "ASSIGN", "PLUS", "MINUS", "LESS_OR_EQUAL", "NOT_EQUAL", "LESS", 
			"GREATER_OR_EQUAL", "GREATER", "MUL", "QUOTIENT", "AMPERSAND", "BRACE", 
			"ALLOWED", "AND", "AS", "ASC", "AUTOORDER", "BETWEEN", "BY_EN", "CASE", 
			"CAST", "DESC", "DISTINCT", "DROP", "ELSE", "END", "ESCAPE", "FALSE", 
			"FROM", "HAVING", "HIERARCHY", "INTO", "IS", "ISNULL", "LIKE", "NOT", 
			"NULL", "OF", "ON_EN", "OR", "OVERALL", "PO_RU", "SELECT", "THEN", "TOP", 
			"TOTALS", "TRUE", "UNDEFINED", "WHEN", "WHERE", "ACOS", "ASIN", "ATAN", 
			"AVG", "BEGINOFPERIOD", "BOOLEAN", "COS", "COUNT", "DATE", "DATEADD", 
			"DATEDIFF", "DATETIME", "DAY", "DAYOFYEAR", "EMPTYTABLE", "EMPTYREF", 
			"ENDOFPERIOD", "EXP", "HALFYEAR", "HOUR", "INT", "LOG", "LOG10", "LOWER", 
			"MAX", "MIN", "MINUTE", "MONTH", "NUMBER", "QUARTER", "ONLY", "PERIODS", 
			"REFS", "PRESENTATION", "RECORDAUTONUMBER", "REFPRESENTATION", "POW", 
			"ROUND", "SECOND", "SIN", "SQRT", "STOREDDATASIZE", "STRING", "STRINGLENGTH", 
			"STRFIND", "STRREPLACE", "SUBSTRING", "SUM", "TAN", "TENDAYS", "TRIMALL", 
			"TRIML", "TRIMR", "TYPE", "UPPER", "VALUE", "VALUETYPE", "WEEK", "WEEKDAY", 
			"YEAR", "UUID", "ACCOUNTING_REGISTER_TYPE", "ACCUMULATION_REGISTER_TYPE", 
			"BUSINESS_PROCESS_TYPE", "CALCULATION_REGISTER_TYPE", "CATALOG_TYPE", 
			"CHART_OF_ACCOUNTS_TYPE", "CHART_OF_CALCULATION_TYPES_TYPE", "CHART_OF_CHARACTERISTIC_TYPES_TYPE", 
			"CONSTANT_TYPE", "DOCUMENT_TYPE", "DOCUMENT_JOURNAL_TYPE", "ENUM_TYPE", 
			"EXCHANGE_PLAN_TYPE", "EXTERNAL_DATA_SOURCE_TYPE", "FILTER_CRITERION_TYPE", 
			"INFORMATION_REGISTER_TYPE", "SEQUENCE_TYPE", "TASK_TYPE", "ROUTEPOINT_FIELD", 
			"INDEX", "GROUP", "ORDER", "GROUPEDBY", "GROUPING", "SET", "RIGHT", "LEFT", 
			"INNER", "FULL", "JOIN", "OUTER", "FOR", "UPDATE", "ALL", "UNION", "HIERARCHY_FOR_IN", 
			"IN", "DECIMAL", "FLOAT", "STR", "INCORRECT_IDENTIFIER", "IDENTIFIER", 
			"UNKNOWN", "PARAMETER_IDENTIFIER", "ACTUAL_ACTION_PERIOD_VT", "BALANCE_VT", 
			"BALANCE_AND_TURNOVERS_VT", "BOUNDARIES_VT", "DR_CR_TURNOVERS_VT", "EXT_DIMENSIONS_VT", 
			"RECORDS_WITH_EXT_DIMENSIONS_VT", "SCHEDULE_DATA_VT", "SLICEFIRST_VT", 
			"SLICELAST_VT", "TASK_BY_PERFORMER_VT", "TURNOVERS_VT", "BRACE_IDENTIFIER", 
			"BRACE_START", "EDS_TABLE", "EDS_CUBE", "EDS_CUBE_DIMTABLE"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "SDBLParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public SDBLParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QueryPackageContext extends BSLParserRuleContext {
		public List queries() {
			return getRuleContexts(QueriesContext.class);
		}
		public QueriesContext queries(int i) {
			return getRuleContext(QueriesContext.class,i);
		}
		public TerminalNode EOF() { return getToken(SDBLParser.EOF, 0); }
		public List SEMICOLON() { return getTokens(SDBLParser.SEMICOLON); }
		public TerminalNode SEMICOLON(int i) {
			return getToken(SDBLParser.SEMICOLON, i);
		}
		public QueryPackageContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_queryPackage; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterQueryPackage(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitQueryPackage(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitQueryPackage(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QueryPackageContext queryPackage() throws RecognitionException {
		QueryPackageContext _localctx = new QueryPackageContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_queryPackage);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(122);
			queries();
			setState(127);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(123);
					match(SEMICOLON);
					setState(124);
					queries();
					}
					} 
				}
				setState(129);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			}
			setState(131);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEMICOLON) {
				{
				setState(130);
				match(SEMICOLON);
				}
			}

			setState(133);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QueriesContext extends BSLParserRuleContext {
		public SelectQueryContext selectQuery() {
			return getRuleContext(SelectQueryContext.class,0);
		}
		public DropTableQueryContext dropTableQuery() {
			return getRuleContext(DropTableQueryContext.class,0);
		}
		public QueriesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_queries; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterQueries(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitQueries(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitQueries(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QueriesContext queries() throws RecognitionException {
		QueriesContext _localctx = new QueriesContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_queries);
		try {
			setState(137);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(135);
				selectQuery();
				}
				break;
			case DROP:
				enterOuterAlt(_localctx, 2);
				{
				setState(136);
				dropTableQuery();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DropTableQueryContext extends BSLParserRuleContext {
		public IdentifierContext temporaryTableName;
		public TerminalNode DROP() { return getToken(SDBLParser.DROP, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public DropTableQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dropTableQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterDropTableQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitDropTableQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitDropTableQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DropTableQueryContext dropTableQuery() throws RecognitionException {
		DropTableQueryContext _localctx = new DropTableQueryContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_dropTableQuery);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(139);
			match(DROP);
			setState(140);
			((DropTableQueryContext)_localctx).temporaryTableName = identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SelectQueryContext extends BSLParserRuleContext {
		public Token autoorder;
		public OrderByContext orders;
		public TotalByContext totals;
		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class,0);
		}
		public TerminalNode AUTOORDER() { return getToken(SDBLParser.AUTOORDER, 0); }
		public OrderByContext orderBy() {
			return getRuleContext(OrderByContext.class,0);
		}
		public TotalByContext totalBy() {
			return getRuleContext(TotalByContext.class,0);
		}
		public SelectQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterSelectQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitSelectQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitSelectQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectQueryContext selectQuery() throws RecognitionException {
		SelectQueryContext _localctx = new SelectQueryContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_selectQuery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(142);
			subquery();
			setState(169);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				{
				{
				setState(143);
				((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
				setState(144);
				((SelectQueryContext)_localctx).orders = orderBy();
				setState(145);
				((SelectQueryContext)_localctx).totals = totalBy();
				}
				}
				break;
			case 2:
				{
				{
				setState(147);
				((SelectQueryContext)_localctx).orders = orderBy();
				setState(148);
				((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
				setState(149);
				((SelectQueryContext)_localctx).totals = totalBy();
				}
				}
				break;
			case 3:
				{
				{
				setState(151);
				((SelectQueryContext)_localctx).orders = orderBy();
				setState(152);
				((SelectQueryContext)_localctx).totals = totalBy();
				setState(153);
				((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
				}
				}
				break;
			case 4:
				{
				{
				setState(155);
				((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
				setState(158);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case ORDER:
					{
					setState(156);
					((SelectQueryContext)_localctx).orders = orderBy();
					}
					break;
				case TOTALS:
					{
					setState(157);
					((SelectQueryContext)_localctx).totals = totalBy();
					}
					break;
				case EOF:
				case SEMICOLON:
					break;
				default:
					break;
				}
				}
				}
				break;
			case 5:
				{
				{
				setState(160);
				((SelectQueryContext)_localctx).orders = orderBy();
				setState(163);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case AUTOORDER:
					{
					setState(161);
					((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
					}
					break;
				case TOTALS:
					{
					setState(162);
					((SelectQueryContext)_localctx).totals = totalBy();
					}
					break;
				case EOF:
				case SEMICOLON:
					break;
				default:
					break;
				}
				}
				}
				break;
			case 6:
				{
				{
				setState(165);
				((SelectQueryContext)_localctx).totals = totalBy();
				setState(167);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==AUTOORDER) {
					{
					setState(166);
					((SelectQueryContext)_localctx).autoorder = match(AUTOORDER);
					}
				}

				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SubqueryContext extends BSLParserRuleContext {
		public QueryContext main;
		public UnionContext union;
		public List unions = new ArrayList();
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public OrderByContext orderBy() {
			return getRuleContext(OrderByContext.class,0);
		}
		public List union() {
			return getRuleContexts(UnionContext.class);
		}
		public UnionContext union(int i) {
			return getRuleContext(UnionContext.class,i);
		}
		public SubqueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subquery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterSubquery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitSubquery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitSubquery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubqueryContext subquery() throws RecognitionException {
		SubqueryContext _localctx = new SubqueryContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_subquery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(171);
			((SubqueryContext)_localctx).main = query();
			setState(173);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				{
				setState(172);
				orderBy();
				}
				break;
			}
			setState(180);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==UNION) {
				{
				setState(176); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(175);
					((SubqueryContext)_localctx).union = union();
					((SubqueryContext)_localctx).unions.add(((SubqueryContext)_localctx).union);
					}
					}
					setState(178); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==UNION );
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnionContext extends BSLParserRuleContext {
		public TerminalNode UNION() { return getToken(SDBLParser.UNION, 0); }
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public TerminalNode ALL() { return getToken(SDBLParser.ALL, 0); }
		public OrderByContext orderBy() {
			return getRuleContext(OrderByContext.class,0);
		}
		public UnionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_union; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterUnion(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitUnion(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitUnion(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnionContext union() throws RecognitionException {
		UnionContext _localctx = new UnionContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_union);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(182);
			match(UNION);
			setState(184);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ALL) {
				{
				setState(183);
				match(ALL);
				}
			}

			setState(186);
			query();
			setState(188);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				{
				setState(187);
				orderBy();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QueryContext extends BSLParserRuleContext {
		public SelectedFieldsContext columns;
		public IdentifierContext temporaryTableName;
		public DataSourcesContext from;
		public LogicalExpressionContext where;
		public GroupByItemContext groupBy;
		public LogicalExpressionContext having;
		public MdoContext forUpdate;
		public IndexingItemContext indexingItem;
		public List indexes = new ArrayList();
		public TerminalNode SELECT() { return getToken(SDBLParser.SELECT, 0); }
		public SelectedFieldsContext selectedFields() {
			return getRuleContext(SelectedFieldsContext.class,0);
		}
		public LimitationsContext limitations() {
			return getRuleContext(LimitationsContext.class,0);
		}
		public TerminalNode INTO() { return getToken(SDBLParser.INTO, 0); }
		public TerminalNode FROM() { return getToken(SDBLParser.FROM, 0); }
		public TerminalNode WHERE() { return getToken(SDBLParser.WHERE, 0); }
		public TerminalNode GROUP() { return getToken(SDBLParser.GROUP, 0); }
		public TerminalNode HAVING() { return getToken(SDBLParser.HAVING, 0); }
		public TerminalNode FOR() { return getToken(SDBLParser.FOR, 0); }
		public TerminalNode UPDATE() { return getToken(SDBLParser.UPDATE, 0); }
		public TerminalNode INDEX() { return getToken(SDBLParser.INDEX, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public DataSourcesContext dataSources() {
			return getRuleContext(DataSourcesContext.class,0);
		}
		public List logicalExpression() {
			return getRuleContexts(LogicalExpressionContext.class);
		}
		public LogicalExpressionContext logicalExpression(int i) {
			return getRuleContext(LogicalExpressionContext.class,i);
		}
		public List BY_EN() { return getTokens(SDBLParser.BY_EN); }
		public TerminalNode BY_EN(int i) {
			return getToken(SDBLParser.BY_EN, i);
		}
		public List PO_RU() { return getTokens(SDBLParser.PO_RU); }
		public TerminalNode PO_RU(int i) {
			return getToken(SDBLParser.PO_RU, i);
		}
		public GroupByItemContext groupByItem() {
			return getRuleContext(GroupByItemContext.class,0);
		}
		public List indexingItem() {
			return getRuleContexts(IndexingItemContext.class);
		}
		public IndexingItemContext indexingItem(int i) {
			return getRuleContext(IndexingItemContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public QueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_query; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QueryContext query() throws RecognitionException {
		QueryContext _localctx = new QueryContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_query);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(190);
			match(SELECT);
			setState(192);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503600702160896L) != 0)) {
				{
				setState(191);
				limitations();
				}
			}

			setState(194);
			((QueryContext)_localctx).columns = selectedFields();
			setState(197);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==INTO) {
				{
				setState(195);
				match(INTO);
				setState(196);
				((QueryContext)_localctx).temporaryTableName = identifier();
				}
			}

			setState(201);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==FROM) {
				{
				setState(199);
				match(FROM);
				setState(200);
				((QueryContext)_localctx).from = dataSources();
				}
			}

			setState(205);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==WHERE) {
				{
				setState(203);
				match(WHERE);
				setState(204);
				((QueryContext)_localctx).where = logicalExpression();
				}
			}

			setState(210);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==GROUP) {
				{
				setState(207);
				match(GROUP);
				setState(208);
				_la = _input.LA(1);
				if ( !(_la==BY_EN || _la==PO_RU) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(209);
				((QueryContext)_localctx).groupBy = groupByItem();
				}
			}

			setState(214);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==HAVING) {
				{
				setState(212);
				match(HAVING);
				setState(213);
				((QueryContext)_localctx).having = logicalExpression();
				}
			}

			setState(221);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==FOR) {
				{
				setState(216);
				match(FOR);
				setState(217);
				match(UPDATE);
				setState(219);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((((_la - 119)) & ~0x3f) == 0 && ((1L << (_la - 119)) & 262143L) != 0)) {
					{
					setState(218);
					((QueryContext)_localctx).forUpdate = mdo();
					}
				}

				}
			}

			setState(233);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==INDEX) {
				{
				setState(223);
				match(INDEX);
				setState(224);
				_la = _input.LA(1);
				if ( !(_la==BY_EN || _la==PO_RU) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(225);
				((QueryContext)_localctx).indexingItem = indexingItem();
				((QueryContext)_localctx).indexes.add(((QueryContext)_localctx).indexingItem);
				setState(230);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(226);
					match(COMMA);
					setState(227);
					((QueryContext)_localctx).indexingItem = indexingItem();
					((QueryContext)_localctx).indexes.add(((QueryContext)_localctx).indexingItem);
					}
					}
					setState(232);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LimitationsContext extends BSLParserRuleContext {
		public TopContext top() {
			return getRuleContext(TopContext.class,0);
		}
		public TerminalNode DISTINCT() { return getToken(SDBLParser.DISTINCT, 0); }
		public TerminalNode ALLOWED() { return getToken(SDBLParser.ALLOWED, 0); }
		public LimitationsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limitations; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterLimitations(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitLimitations(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitLimitations(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LimitationsContext limitations() throws RecognitionException {
		LimitationsContext _localctx = new LimitationsContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_limitations);
		try {
			setState(276);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(238);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case TOP:
					{
					setState(235);
					top();
					}
					break;
				case DISTINCT:
					{
					setState(236);
					match(DISTINCT);
					}
					break;
				case ALLOWED:
					{
					setState(237);
					match(ALLOWED);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(240);
				match(ALLOWED);
				setState(241);
				match(DISTINCT);
				setState(242);
				top();
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(243);
				match(ALLOWED);
				setState(244);
				top();
				setState(245);
				match(DISTINCT);
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				{
				setState(247);
				top();
				setState(248);
				match(ALLOWED);
				setState(249);
				match(DISTINCT);
				}
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				{
				setState(251);
				top();
				setState(252);
				match(DISTINCT);
				setState(253);
				match(ALLOWED);
				}
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				{
				setState(255);
				match(DISTINCT);
				setState(256);
				match(ALLOWED);
				setState(257);
				top();
				}
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				{
				setState(258);
				match(DISTINCT);
				setState(259);
				top();
				setState(260);
				match(ALLOWED);
				}
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				{
				setState(262);
				match(ALLOWED);
				setState(263);
				match(DISTINCT);
				}
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				{
				setState(264);
				match(ALLOWED);
				setState(265);
				top();
				}
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				{
				setState(266);
				match(DISTINCT);
				setState(267);
				match(ALLOWED);
				}
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				{
				setState(268);
				match(DISTINCT);
				setState(269);
				top();
				}
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				{
				setState(270);
				top();
				setState(271);
				match(ALLOWED);
				}
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				{
				setState(273);
				top();
				setState(274);
				match(DISTINCT);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TopContext extends BSLParserRuleContext {
		public Token count;
		public TerminalNode TOP() { return getToken(SDBLParser.TOP, 0); }
		public TerminalNode DECIMAL() { return getToken(SDBLParser.DECIMAL, 0); }
		public TopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_top; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterTop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitTop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitTop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TopContext top() throws RecognitionException {
		TopContext _localctx = new TopContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_top);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(278);
			match(TOP);
			setState(279);
			((TopContext)_localctx).count = match(DECIMAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SelectedFieldsContext extends BSLParserRuleContext {
		public SelectedFieldContext selectedField;
		public List fields = new ArrayList();
		public List selectedField() {
			return getRuleContexts(SelectedFieldContext.class);
		}
		public SelectedFieldContext selectedField(int i) {
			return getRuleContext(SelectedFieldContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public SelectedFieldsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectedFields; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterSelectedFields(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitSelectedFields(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitSelectedFields(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectedFieldsContext selectedFields() throws RecognitionException {
		SelectedFieldsContext _localctx = new SelectedFieldsContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_selectedFields);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(281);
			((SelectedFieldsContext)_localctx).selectedField = selectedField();
			((SelectedFieldsContext)_localctx).fields.add(((SelectedFieldsContext)_localctx).selectedField);
			setState(286);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(282);
				match(COMMA);
				setState(283);
				((SelectedFieldsContext)_localctx).selectedField = selectedField();
				((SelectedFieldsContext)_localctx).fields.add(((SelectedFieldsContext)_localctx).selectedField);
				}
				}
				setState(288);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SelectedFieldContext extends BSLParserRuleContext {
		public AsteriskFieldContext asteriskField() {
			return getRuleContext(AsteriskFieldContext.class,0);
		}
		public ColumnFieldContext columnField() {
			return getRuleContext(ColumnFieldContext.class,0);
		}
		public EmptyTableFieldContext emptyTableField() {
			return getRuleContext(EmptyTableFieldContext.class,0);
		}
		public InlineTableFieldContext inlineTableField() {
			return getRuleContext(InlineTableFieldContext.class,0);
		}
		public ExpressionFieldContext expressionField() {
			return getRuleContext(ExpressionFieldContext.class,0);
		}
		public AliasContext alias() {
			return getRuleContext(AliasContext.class,0);
		}
		public SelectedFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectedField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterSelectedField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitSelectedField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitSelectedField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectedFieldContext selectedField() throws RecognitionException {
		SelectedFieldContext _localctx = new SelectedFieldContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_selectedField);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(294);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(289);
				asteriskField();
				}
				break;
			case 2:
				{
				setState(290);
				columnField();
				}
				break;
			case 3:
				{
				setState(291);
				emptyTableField();
				}
				break;
			case 4:
				{
				setState(292);
				inlineTableField();
				}
				break;
			case 5:
				{
				setState(293);
				expressionField();
				}
				break;
			}
			setState(297);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				{
				setState(296);
				alias();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AsteriskFieldContext extends BSLParserRuleContext {
		public IdentifierContext tableName;
		public TerminalNode MUL() { return getToken(SDBLParser.MUL, 0); }
		public List DOT() { return getTokens(SDBLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(SDBLParser.DOT, i);
		}
		public List identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public AsteriskFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_asteriskField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterAsteriskField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitAsteriskField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitAsteriskField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AsteriskFieldContext asteriskField() throws RecognitionException {
		AsteriskFieldContext _localctx = new AsteriskFieldContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_asteriskField);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(304);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -278095067229454336L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 140707490668543L) != 0)) {
				{
				{
				setState(299);
				((AsteriskFieldContext)_localctx).tableName = identifier();
				setState(300);
				match(DOT);
				}
				}
				setState(306);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(307);
			match(MUL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionFieldContext extends BSLParserRuleContext {
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public ExpressionFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterExpressionField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitExpressionField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitExpressionField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionFieldContext expressionField() throws RecognitionException {
		ExpressionFieldContext _localctx = new ExpressionFieldContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_expressionField);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(309);
			logicalExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ColumnFieldContext extends BSLParserRuleContext {
		public TerminalNode NULL() { return getToken(SDBLParser.NULL, 0); }
		public RecordAutoNumberFunctionContext recordAutoNumberFunction() {
			return getRuleContext(RecordAutoNumberFunctionContext.class,0);
		}
		public ColumnFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterColumnField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitColumnField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitColumnField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnFieldContext columnField() throws RecognitionException {
		ColumnFieldContext _localctx = new ColumnFieldContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_columnField);
		try {
			setState(313);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case NULL:
				enterOuterAlt(_localctx, 1);
				{
				setState(311);
				match(NULL);
				}
				break;
			case RECORDAUTONUMBER:
				enterOuterAlt(_localctx, 2);
				{
				setState(312);
				recordAutoNumberFunction();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EmptyTableFieldContext extends BSLParserRuleContext {
		public Token emptyTable;
		public TerminalNode DOT() { return getToken(SDBLParser.DOT, 0); }
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public EmptyTableColumnsContext emptyTableColumns() {
			return getRuleContext(EmptyTableColumnsContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode EMPTYTABLE() { return getToken(SDBLParser.EMPTYTABLE, 0); }
		public EmptyTableFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_emptyTableField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterEmptyTableField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitEmptyTableField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitEmptyTableField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EmptyTableFieldContext emptyTableField() throws RecognitionException {
		EmptyTableFieldContext _localctx = new EmptyTableFieldContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_emptyTableField);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(315);
			((EmptyTableFieldContext)_localctx).emptyTable = match(EMPTYTABLE);
			setState(316);
			match(DOT);
			setState(317);
			match(LPAREN);
			setState(318);
			emptyTableColumns();
			setState(319);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EmptyTableColumnsContext extends BSLParserRuleContext {
		public AliasContext alias;
		public List columns = new ArrayList();
		public List alias() {
			return getRuleContexts(AliasContext.class);
		}
		public AliasContext alias(int i) {
			return getRuleContext(AliasContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public EmptyTableColumnsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_emptyTableColumns; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterEmptyTableColumns(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitEmptyTableColumns(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitEmptyTableColumns(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EmptyTableColumnsContext emptyTableColumns() throws RecognitionException {
		EmptyTableColumnsContext _localctx = new EmptyTableColumnsContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_emptyTableColumns);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(321);
			((EmptyTableColumnsContext)_localctx).alias = alias();
			((EmptyTableColumnsContext)_localctx).columns.add(((EmptyTableColumnsContext)_localctx).alias);
			setState(326);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(322);
				match(COMMA);
				setState(323);
				((EmptyTableColumnsContext)_localctx).alias = alias();
				((EmptyTableColumnsContext)_localctx).columns.add(((EmptyTableColumnsContext)_localctx).alias);
				}
				}
				setState(328);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InlineTableFieldContext extends BSLParserRuleContext {
		public ColumnContext inlineTable;
		public SelectedFieldsContext inlineTableFields;
		public TerminalNode DOT() { return getToken(SDBLParser.DOT, 0); }
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public ColumnContext column() {
			return getRuleContext(ColumnContext.class,0);
		}
		public SelectedFieldsContext selectedFields() {
			return getRuleContext(SelectedFieldsContext.class,0);
		}
		public InlineTableFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inlineTableField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterInlineTableField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitInlineTableField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitInlineTableField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InlineTableFieldContext inlineTableField() throws RecognitionException {
		InlineTableFieldContext _localctx = new InlineTableFieldContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_inlineTableField);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(329);
			((InlineTableFieldContext)_localctx).inlineTable = column();
			setState(330);
			match(DOT);
			setState(331);
			match(LPAREN);
			setState(332);
			((InlineTableFieldContext)_localctx).inlineTableFields = selectedFields();
			setState(333);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RecordAutoNumberFunctionContext extends BSLParserRuleContext {
		public Token doCall;
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode RECORDAUTONUMBER() { return getToken(SDBLParser.RECORDAUTONUMBER, 0); }
		public RecordAutoNumberFunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_recordAutoNumberFunction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterRecordAutoNumberFunction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitRecordAutoNumberFunction(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitRecordAutoNumberFunction(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RecordAutoNumberFunctionContext recordAutoNumberFunction() throws RecognitionException {
		RecordAutoNumberFunctionContext _localctx = new RecordAutoNumberFunctionContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_recordAutoNumberFunction);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(335);
			((RecordAutoNumberFunctionContext)_localctx).doCall = match(RECORDAUTONUMBER);
			setState(336);
			match(LPAREN);
			setState(337);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class GroupByItemContext extends BSLParserRuleContext {
		public ExpressionListContext expressionList;
		public List groupingSet = new ArrayList();
		public ExpressionContext expression;
		public List groupBy = new ArrayList();
		public TerminalNode GROUPING() { return getToken(SDBLParser.GROUPING, 0); }
		public TerminalNode SET() { return getToken(SDBLParser.SET, 0); }
		public List LPAREN() { return getTokens(SDBLParser.LPAREN); }
		public TerminalNode LPAREN(int i) {
			return getToken(SDBLParser.LPAREN, i);
		}
		public List RPAREN() { return getTokens(SDBLParser.RPAREN); }
		public TerminalNode RPAREN(int i) {
			return getToken(SDBLParser.RPAREN, i);
		}
		public List expressionList() {
			return getRuleContexts(ExpressionListContext.class);
		}
		public ExpressionListContext expressionList(int i) {
			return getRuleContext(ExpressionListContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public GroupByItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupByItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterGroupByItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitGroupByItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitGroupByItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GroupByItemContext groupByItem() throws RecognitionException {
		GroupByItemContext _localctx = new GroupByItemContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_groupByItem);
		int _la;
		try {
			setState(365);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case GROUPING:
				enterOuterAlt(_localctx, 1);
				{
				setState(339);
				match(GROUPING);
				setState(340);
				match(SET);
				setState(341);
				match(LPAREN);
				{
				setState(342);
				match(LPAREN);
				setState(343);
				((GroupByItemContext)_localctx).expressionList = expressionList();
				((GroupByItemContext)_localctx).groupingSet.add(((GroupByItemContext)_localctx).expressionList);
				setState(344);
				match(RPAREN);
				setState(352);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(345);
					match(COMMA);
					setState(346);
					match(LPAREN);
					setState(347);
					((GroupByItemContext)_localctx).expressionList = expressionList();
					((GroupByItemContext)_localctx).groupingSet.add(((GroupByItemContext)_localctx).expressionList);
					setState(348);
					match(RPAREN);
					}
					}
					setState(354);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				setState(355);
				match(RPAREN);
				}
				break;
			case LPAREN:
			case PLUS:
			case MINUS:
			case AMPERSAND:
			case CASE:
			case CAST:
			case DROP:
			case END:
			case FALSE:
			case ISNULL:
			case NULL:
			case SELECT:
			case TOTALS:
			case TRUE:
			case UNDEFINED:
			case WHEN:
			case ACOS:
			case ASIN:
			case ATAN:
			case AVG:
			case BEGINOFPERIOD:
			case BOOLEAN:
			case COS:
			case COUNT:
			case DATE:
			case DATEADD:
			case DATEDIFF:
			case DATETIME:
			case DAY:
			case DAYOFYEAR:
			case EMPTYTABLE:
			case EMPTYREF:
			case ENDOFPERIOD:
			case EXP:
			case HALFYEAR:
			case HOUR:
			case INT:
			case LOG:
			case LOG10:
			case LOWER:
			case MAX:
			case MIN:
			case MINUTE:
			case MONTH:
			case NUMBER:
			case QUARTER:
			case ONLY:
			case PERIODS:
			case REFS:
			case PRESENTATION:
			case RECORDAUTONUMBER:
			case REFPRESENTATION:
			case POW:
			case ROUND:
			case SECOND:
			case SIN:
			case SQRT:
			case STOREDDATASIZE:
			case STRING:
			case STRINGLENGTH:
			case STRFIND:
			case STRREPLACE:
			case SUBSTRING:
			case SUM:
			case TAN:
			case TENDAYS:
			case TRIMALL:
			case TRIML:
			case TRIMR:
			case TYPE:
			case UPPER:
			case VALUE:
			case VALUETYPE:
			case WEEK:
			case WEEKDAY:
			case YEAR:
			case UUID:
			case ACCOUNTING_REGISTER_TYPE:
			case ACCUMULATION_REGISTER_TYPE:
			case BUSINESS_PROCESS_TYPE:
			case CALCULATION_REGISTER_TYPE:
			case CATALOG_TYPE:
			case CHART_OF_ACCOUNTS_TYPE:
			case CHART_OF_CALCULATION_TYPES_TYPE:
			case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
			case CONSTANT_TYPE:
			case DOCUMENT_TYPE:
			case DOCUMENT_JOURNAL_TYPE:
			case ENUM_TYPE:
			case EXCHANGE_PLAN_TYPE:
			case EXTERNAL_DATA_SOURCE_TYPE:
			case FILTER_CRITERION_TYPE:
			case INFORMATION_REGISTER_TYPE:
			case SEQUENCE_TYPE:
			case TASK_TYPE:
			case ROUTEPOINT_FIELD:
			case INDEX:
			case GROUP:
			case ORDER:
			case GROUPEDBY:
			case SET:
			case RIGHT:
			case LEFT:
			case INNER:
			case FULL:
			case JOIN:
			case OUTER:
			case FOR:
			case UPDATE:
			case ALL:
			case UNION:
			case DECIMAL:
			case FLOAT:
			case STR:
			case IDENTIFIER:
			case ACTUAL_ACTION_PERIOD_VT:
			case BALANCE_VT:
			case BALANCE_AND_TURNOVERS_VT:
			case BOUNDARIES_VT:
			case DR_CR_TURNOVERS_VT:
			case EXT_DIMENSIONS_VT:
			case RECORDS_WITH_EXT_DIMENSIONS_VT:
			case SCHEDULE_DATA_VT:
			case SLICEFIRST_VT:
			case SLICELAST_VT:
			case TASK_BY_PERFORMER_VT:
			case TURNOVERS_VT:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(357);
				((GroupByItemContext)_localctx).expression = expression(0);
				((GroupByItemContext)_localctx).groupBy.add(((GroupByItemContext)_localctx).expression);
				setState(362);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(358);
					match(COMMA);
					setState(359);
					((GroupByItemContext)_localctx).expression = expression(0);
					((GroupByItemContext)_localctx).groupBy.add(((GroupByItemContext)_localctx).expression);
					}
					}
					setState(364);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IndexingItemContext extends BSLParserRuleContext {
		public ParameterContext parameter() {
			return getRuleContext(ParameterContext.class,0);
		}
		public ColumnContext column() {
			return getRuleContext(ColumnContext.class,0);
		}
		public IndexingItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexingItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterIndexingItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitIndexingItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitIndexingItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexingItemContext indexingItem() throws RecognitionException {
		IndexingItemContext _localctx = new IndexingItemContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_indexingItem);
		try {
			setState(369);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AMPERSAND:
				enterOuterAlt(_localctx, 1);
				{
				setState(367);
				parameter();
				}
				break;
			case DROP:
			case END:
			case ISNULL:
			case SELECT:
			case TOTALS:
			case ACOS:
			case ASIN:
			case ATAN:
			case AVG:
			case BEGINOFPERIOD:
			case BOOLEAN:
			case COS:
			case COUNT:
			case DATE:
			case DATEADD:
			case DATEDIFF:
			case DATETIME:
			case DAY:
			case DAYOFYEAR:
			case EMPTYTABLE:
			case EMPTYREF:
			case ENDOFPERIOD:
			case EXP:
			case HALFYEAR:
			case HOUR:
			case INT:
			case LOG:
			case LOG10:
			case LOWER:
			case MAX:
			case MIN:
			case MINUTE:
			case MONTH:
			case NUMBER:
			case QUARTER:
			case ONLY:
			case PERIODS:
			case REFS:
			case PRESENTATION:
			case RECORDAUTONUMBER:
			case REFPRESENTATION:
			case POW:
			case ROUND:
			case SECOND:
			case SIN:
			case SQRT:
			case STOREDDATASIZE:
			case STRING:
			case STRINGLENGTH:
			case STRFIND:
			case STRREPLACE:
			case SUBSTRING:
			case SUM:
			case TAN:
			case TENDAYS:
			case TRIMALL:
			case TRIML:
			case TRIMR:
			case TYPE:
			case UPPER:
			case VALUE:
			case VALUETYPE:
			case WEEK:
			case WEEKDAY:
			case YEAR:
			case UUID:
			case ACCOUNTING_REGISTER_TYPE:
			case ACCUMULATION_REGISTER_TYPE:
			case BUSINESS_PROCESS_TYPE:
			case CALCULATION_REGISTER_TYPE:
			case CATALOG_TYPE:
			case CHART_OF_ACCOUNTS_TYPE:
			case CHART_OF_CALCULATION_TYPES_TYPE:
			case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
			case CONSTANT_TYPE:
			case DOCUMENT_TYPE:
			case DOCUMENT_JOURNAL_TYPE:
			case ENUM_TYPE:
			case EXCHANGE_PLAN_TYPE:
			case EXTERNAL_DATA_SOURCE_TYPE:
			case FILTER_CRITERION_TYPE:
			case INFORMATION_REGISTER_TYPE:
			case SEQUENCE_TYPE:
			case TASK_TYPE:
			case ROUTEPOINT_FIELD:
			case INDEX:
			case GROUP:
			case ORDER:
			case SET:
			case RIGHT:
			case LEFT:
			case INNER:
			case FULL:
			case JOIN:
			case OUTER:
			case FOR:
			case UPDATE:
			case ALL:
			case UNION:
			case IDENTIFIER:
			case ACTUAL_ACTION_PERIOD_VT:
			case BALANCE_VT:
			case BALANCE_AND_TURNOVERS_VT:
			case BOUNDARIES_VT:
			case DR_CR_TURNOVERS_VT:
			case EXT_DIMENSIONS_VT:
			case RECORDS_WITH_EXT_DIMENSIONS_VT:
			case SCHEDULE_DATA_VT:
			case SLICEFIRST_VT:
			case SLICELAST_VT:
			case TASK_BY_PERFORMER_VT:
			case TURNOVERS_VT:
				enterOuterAlt(_localctx, 2);
				{
				setState(368);
				column();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OrderByContext extends BSLParserRuleContext {
		public OrdersByExpessionContext ordersByExpession;
		public List orders = new ArrayList();
		public TerminalNode ORDER() { return getToken(SDBLParser.ORDER, 0); }
		public TerminalNode BY_EN() { return getToken(SDBLParser.BY_EN, 0); }
		public TerminalNode PO_RU() { return getToken(SDBLParser.PO_RU, 0); }
		public List ordersByExpession() {
			return getRuleContexts(OrdersByExpessionContext.class);
		}
		public OrdersByExpessionContext ordersByExpession(int i) {
			return getRuleContext(OrdersByExpessionContext.class,i);
		}
		public TerminalNode COMMA() { return getToken(SDBLParser.COMMA, 0); }
		public OrderByContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orderBy; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterOrderBy(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitOrderBy(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitOrderBy(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OrderByContext orderBy() throws RecognitionException {
		OrderByContext _localctx = new OrderByContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_orderBy);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(371);
			match(ORDER);
			setState(372);
			_la = _input.LA(1);
			if ( !(_la==BY_EN || _la==PO_RU) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(373);
			((OrderByContext)_localctx).ordersByExpession = ordersByExpession();
			((OrderByContext)_localctx).orders.add(((OrderByContext)_localctx).ordersByExpession);
			setState(376);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(374);
				match(COMMA);
				setState(375);
				((OrderByContext)_localctx).ordersByExpession = ordersByExpession();
				((OrderByContext)_localctx).orders.add(((OrderByContext)_localctx).ordersByExpession);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OrdersByExpessionContext extends BSLParserRuleContext {
		public Token direction;
		public Token hierarchy;
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode ASC() { return getToken(SDBLParser.ASC, 0); }
		public TerminalNode DESC() { return getToken(SDBLParser.DESC, 0); }
		public TerminalNode HIERARCHY() { return getToken(SDBLParser.HIERARCHY, 0); }
		public OrdersByExpessionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ordersByExpession; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterOrdersByExpession(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitOrdersByExpession(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitOrdersByExpession(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OrdersByExpessionContext ordersByExpession() throws RecognitionException {
		OrdersByExpessionContext _localctx = new OrdersByExpessionContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_ordersByExpession);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(378);
			expression(0);
			setState(384);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ASC:
			case DESC:
				{
				setState(379);
				((OrdersByExpessionContext)_localctx).direction = _input.LT(1);
				_la = _input.LA(1);
				if ( !(_la==ASC || _la==DESC) ) {
					((OrdersByExpessionContext)_localctx).direction = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case HIERARCHY:
				{
				{
				setState(380);
				((OrdersByExpessionContext)_localctx).hierarchy = match(HIERARCHY);
				setState(382);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==DESC) {
					{
					setState(381);
					((OrdersByExpessionContext)_localctx).direction = match(DESC);
					}
				}

				}
				}
				break;
			case EOF:
			case RPAREN:
			case SEMICOLON:
			case COMMA:
			case AUTOORDER:
			case TOTALS:
			case ORDER:
			case UNION:
				break;
			default:
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TotalByContext extends BSLParserRuleContext {
		public TotalsGroupContext totalsGroup;
		public List totalsGroups = new ArrayList();
		public TerminalNode TOTALS() { return getToken(SDBLParser.TOTALS, 0); }
		public TerminalNode BY_EN() { return getToken(SDBLParser.BY_EN, 0); }
		public TerminalNode PO_RU() { return getToken(SDBLParser.PO_RU, 0); }
		public List totalsGroup() {
			return getRuleContexts(TotalsGroupContext.class);
		}
		public TotalsGroupContext totalsGroup(int i) {
			return getRuleContext(TotalsGroupContext.class,i);
		}
		public SelectedFieldsContext selectedFields() {
			return getRuleContext(SelectedFieldsContext.class,0);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public TotalByContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_totalBy; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterTotalBy(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitTotalBy(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitTotalBy(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TotalByContext totalBy() throws RecognitionException {
		TotalByContext _localctx = new TotalByContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_totalBy);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(386);
			match(TOTALS);
			setState(388);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -151967854621293040L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 140709369724927L) != 0)) {
				{
				setState(387);
				selectedFields();
				}
			}

			setState(390);
			_la = _input.LA(1);
			if ( !(_la==BY_EN || _la==PO_RU) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(391);
			((TotalByContext)_localctx).totalsGroup = totalsGroup();
			((TotalByContext)_localctx).totalsGroups.add(((TotalByContext)_localctx).totalsGroup);
			setState(396);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(392);
				match(COMMA);
				setState(393);
				((TotalByContext)_localctx).totalsGroup = totalsGroup();
				((TotalByContext)_localctx).totalsGroups.add(((TotalByContext)_localctx).totalsGroup);
				}
				}
				setState(398);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TotalsGroupContext extends BSLParserRuleContext {
		public TerminalNode OVERALL() { return getToken(SDBLParser.OVERALL, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public PeriodicContext periodic() {
			return getRuleContext(PeriodicContext.class,0);
		}
		public AliasContext alias() {
			return getRuleContext(AliasContext.class,0);
		}
		public TerminalNode HIERARCHY() { return getToken(SDBLParser.HIERARCHY, 0); }
		public TerminalNode ONLY() { return getToken(SDBLParser.ONLY, 0); }
		public TotalsGroupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_totalsGroup; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterTotalsGroup(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitTotalsGroup(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitTotalsGroup(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TotalsGroupContext totalsGroup() throws RecognitionException {
		TotalsGroupContext _localctx = new TotalsGroupContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_totalsGroup);
		int _la;
		try {
			setState(411);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OVERALL:
				enterOuterAlt(_localctx, 1);
				{
				setState(399);
				match(OVERALL);
				}
				break;
			case LPAREN:
			case PLUS:
			case MINUS:
			case AMPERSAND:
			case CASE:
			case CAST:
			case DROP:
			case END:
			case FALSE:
			case ISNULL:
			case NULL:
			case SELECT:
			case TOTALS:
			case TRUE:
			case UNDEFINED:
			case WHEN:
			case ACOS:
			case ASIN:
			case ATAN:
			case AVG:
			case BEGINOFPERIOD:
			case BOOLEAN:
			case COS:
			case COUNT:
			case DATE:
			case DATEADD:
			case DATEDIFF:
			case DATETIME:
			case DAY:
			case DAYOFYEAR:
			case EMPTYTABLE:
			case EMPTYREF:
			case ENDOFPERIOD:
			case EXP:
			case HALFYEAR:
			case HOUR:
			case INT:
			case LOG:
			case LOG10:
			case LOWER:
			case MAX:
			case MIN:
			case MINUTE:
			case MONTH:
			case NUMBER:
			case QUARTER:
			case ONLY:
			case PERIODS:
			case REFS:
			case PRESENTATION:
			case RECORDAUTONUMBER:
			case REFPRESENTATION:
			case POW:
			case ROUND:
			case SECOND:
			case SIN:
			case SQRT:
			case STOREDDATASIZE:
			case STRING:
			case STRINGLENGTH:
			case STRFIND:
			case STRREPLACE:
			case SUBSTRING:
			case SUM:
			case TAN:
			case TENDAYS:
			case TRIMALL:
			case TRIML:
			case TRIMR:
			case TYPE:
			case UPPER:
			case VALUE:
			case VALUETYPE:
			case WEEK:
			case WEEKDAY:
			case YEAR:
			case UUID:
			case ACCOUNTING_REGISTER_TYPE:
			case ACCUMULATION_REGISTER_TYPE:
			case BUSINESS_PROCESS_TYPE:
			case CALCULATION_REGISTER_TYPE:
			case CATALOG_TYPE:
			case CHART_OF_ACCOUNTS_TYPE:
			case CHART_OF_CALCULATION_TYPES_TYPE:
			case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
			case CONSTANT_TYPE:
			case DOCUMENT_TYPE:
			case DOCUMENT_JOURNAL_TYPE:
			case ENUM_TYPE:
			case EXCHANGE_PLAN_TYPE:
			case EXTERNAL_DATA_SOURCE_TYPE:
			case FILTER_CRITERION_TYPE:
			case INFORMATION_REGISTER_TYPE:
			case SEQUENCE_TYPE:
			case TASK_TYPE:
			case ROUTEPOINT_FIELD:
			case INDEX:
			case GROUP:
			case ORDER:
			case GROUPEDBY:
			case SET:
			case RIGHT:
			case LEFT:
			case INNER:
			case FULL:
			case JOIN:
			case OUTER:
			case FOR:
			case UPDATE:
			case ALL:
			case UNION:
			case DECIMAL:
			case FLOAT:
			case STR:
			case IDENTIFIER:
			case ACTUAL_ACTION_PERIOD_VT:
			case BALANCE_VT:
			case BALANCE_AND_TURNOVERS_VT:
			case BOUNDARIES_VT:
			case DR_CR_TURNOVERS_VT:
			case EXT_DIMENSIONS_VT:
			case RECORDS_WITH_EXT_DIMENSIONS_VT:
			case SCHEDULE_DATA_VT:
			case SLICEFIRST_VT:
			case SLICELAST_VT:
			case TASK_BY_PERFORMER_VT:
			case TURNOVERS_VT:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(400);
				expression(0);
				setState(406);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
				case 1:
					{
					{
					setState(402);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==ONLY) {
						{
						setState(401);
						match(ONLY);
						}
					}

					setState(404);
					match(HIERARCHY);
					}
					}
					break;
				case 2:
					{
					setState(405);
					periodic();
					}
					break;
				}
				setState(409);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -278095067225260032L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 140707490668543L) != 0)) {
					{
					setState(408);
					alias();
					}
				}

				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PeriodicContext extends BSLParserRuleContext {
		public Token periodType;
		public ExpressionContext first;
		public ExpressionContext second;
		public TerminalNode PERIODS() { return getToken(SDBLParser.PERIODS, 0); }
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode SECOND() { return getToken(SDBLParser.SECOND, 0); }
		public TerminalNode MINUTE() { return getToken(SDBLParser.MINUTE, 0); }
		public TerminalNode HOUR() { return getToken(SDBLParser.HOUR, 0); }
		public TerminalNode DAY() { return getToken(SDBLParser.DAY, 0); }
		public TerminalNode WEEK() { return getToken(SDBLParser.WEEK, 0); }
		public TerminalNode MONTH() { return getToken(SDBLParser.MONTH, 0); }
		public TerminalNode QUARTER() { return getToken(SDBLParser.QUARTER, 0); }
		public TerminalNode YEAR() { return getToken(SDBLParser.YEAR, 0); }
		public TerminalNode TENDAYS() { return getToken(SDBLParser.TENDAYS, 0); }
		public TerminalNode HALFYEAR() { return getToken(SDBLParser.HALFYEAR, 0); }
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public PeriodicContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_periodic; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterPeriodic(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitPeriodic(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitPeriodic(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PeriodicContext periodic() throws RecognitionException {
		PeriodicContext _localctx = new PeriodicContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_periodic);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(413);
			match(PERIODS);
			setState(414);
			match(LPAREN);
			setState(415);
			((PeriodicContext)_localctx).periodType = _input.LT(1);
			_la = _input.LA(1);
			if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 176059366686913L) != 0)) ) {
				((PeriodicContext)_localctx).periodType = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(418);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				{
				setState(416);
				match(COMMA);
				setState(417);
				((PeriodicContext)_localctx).first = expression(0);
				}
				break;
			}
			setState(422);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(420);
				match(COMMA);
				setState(421);
				((PeriodicContext)_localctx).second = expression(0);
				}
			}

			setState(424);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ColumnContext extends BSLParserRuleContext {
		public IdentifierContext mdoName;
		public IdentifierContext identifier;
		public List columnNames = new ArrayList();
		public List identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public List DOT() { return getTokens(SDBLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(SDBLParser.DOT, i);
		}
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public ColumnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterColumn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitColumn(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitColumn(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnContext column() throws RecognitionException {
		ColumnContext _localctx = new ColumnContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_column);
		try {
			int _alt;
			setState(441);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(426);
				((ColumnContext)_localctx).mdoName = identifier();
				setState(429); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(427);
						match(DOT);
						setState(428);
						((ColumnContext)_localctx).identifier = identifier();
						((ColumnContext)_localctx).columnNames.add(((ColumnContext)_localctx).identifier);
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(431); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(433);
				((ColumnContext)_localctx).identifier = identifier();
				((ColumnContext)_localctx).columnNames.add(((ColumnContext)_localctx).identifier);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(434);
				mdo();
				setState(437); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(435);
						match(DOT);
						setState(436);
						((ColumnContext)_localctx).identifier = identifier();
						((ColumnContext)_localctx).columnNames.add(((ColumnContext)_localctx).identifier);
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(439); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionContext extends BSLParserRuleContext {
		public Token binaryOperation;
		public PrimitiveExpressionContext primitiveExpression() {
			return getRuleContext(PrimitiveExpressionContext.class,0);
		}
		public FunctionCallContext functionCall() {
			return getRuleContext(FunctionCallContext.class,0);
		}
		public CaseExpressionContext caseExpression() {
			return getRuleContext(CaseExpressionContext.class,0);
		}
		public ColumnContext column() {
			return getRuleContext(ColumnContext.class,0);
		}
		public BracketExpressionContext bracketExpression() {
			return getRuleContext(BracketExpressionContext.class,0);
		}
		public UnaryExpressionContext unaryExpression() {
			return getRuleContext(UnaryExpressionContext.class,0);
		}
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MUL() { return getToken(SDBLParser.MUL, 0); }
		public TerminalNode QUOTIENT() { return getToken(SDBLParser.QUOTIENT, 0); }
		public TerminalNode PLUS() { return getToken(SDBLParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(SDBLParser.MINUS, 0); }
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 52;
		enterRecursionRule(_localctx, 52, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(450);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
			case 1:
				{
				setState(444);
				primitiveExpression();
				}
				break;
			case 2:
				{
				setState(445);
				functionCall();
				}
				break;
			case 3:
				{
				setState(446);
				caseExpression();
				}
				break;
			case 4:
				{
				setState(447);
				column();
				}
				break;
			case 5:
				{
				setState(448);
				bracketExpression();
				}
				break;
			case 6:
				{
				setState(449);
				unaryExpression();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(457);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new ExpressionContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_expression);
					setState(452);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(453);
					((ExpressionContext)_localctx).binaryOperation = _input.LT(1);
					_la = _input.LA(1);
					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 198144L) != 0)) ) {
						((ExpressionContext)_localctx).binaryOperation = (Token)_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(454);
					expression(2);
					}
					} 
				}
				setState(459);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrimitiveExpressionContext extends BSLParserRuleContext {
		public Token booleanValue;
		public DatePartContext year;
		public DatePartContext month;
		public DatePartContext day;
		public DatePartContext hour;
		public DatePartContext minute;
		public DatePartContext second;
		public TerminalNode NULL() { return getToken(SDBLParser.NULL, 0); }
		public TerminalNode UNDEFINED() { return getToken(SDBLParser.UNDEFINED, 0); }
		public MultiStringContext multiString() {
			return getRuleContext(MultiStringContext.class,0);
		}
		public TerminalNode DECIMAL() { return getToken(SDBLParser.DECIMAL, 0); }
		public TerminalNode FLOAT() { return getToken(SDBLParser.FLOAT, 0); }
		public TerminalNode TRUE() { return getToken(SDBLParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(SDBLParser.FALSE, 0); }
		public TerminalNode DATETIME() { return getToken(SDBLParser.DATETIME, 0); }
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public List datePart() {
			return getRuleContexts(DatePartContext.class);
		}
		public DatePartContext datePart(int i) {
			return getRuleContext(DatePartContext.class,i);
		}
		public ParameterContext parameter() {
			return getRuleContext(ParameterContext.class,0);
		}
		public TerminalNode TYPE() { return getToken(SDBLParser.TYPE, 0); }
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public TerminalNode STRING() { return getToken(SDBLParser.STRING, 0); }
		public TerminalNode BOOLEAN() { return getToken(SDBLParser.BOOLEAN, 0); }
		public TerminalNode DATE() { return getToken(SDBLParser.DATE, 0); }
		public TerminalNode NUMBER() { return getToken(SDBLParser.NUMBER, 0); }
		public PrimitiveExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitiveExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterPrimitiveExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitPrimitiveExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitPrimitiveExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimitiveExpressionContext primitiveExpression() throws RecognitionException {
		PrimitiveExpressionContext _localctx = new PrimitiveExpressionContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_primitiveExpression);
		int _la;
		try {
			setState(495);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case NULL:
				enterOuterAlt(_localctx, 1);
				{
				setState(460);
				match(NULL);
				}
				break;
			case UNDEFINED:
				enterOuterAlt(_localctx, 2);
				{
				setState(461);
				match(UNDEFINED);
				}
				break;
			case STR:
				enterOuterAlt(_localctx, 3);
				{
				setState(462);
				multiString();
				}
				break;
			case DECIMAL:
				enterOuterAlt(_localctx, 4);
				{
				setState(463);
				match(DECIMAL);
				}
				break;
			case FLOAT:
				enterOuterAlt(_localctx, 5);
				{
				setState(464);
				match(FLOAT);
				}
				break;
			case FALSE:
			case TRUE:
				enterOuterAlt(_localctx, 6);
				{
				setState(465);
				((PrimitiveExpressionContext)_localctx).booleanValue = _input.LT(1);
				_la = _input.LA(1);
				if ( !(_la==FALSE || _la==TRUE) ) {
					((PrimitiveExpressionContext)_localctx).booleanValue = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case DATETIME:
				enterOuterAlt(_localctx, 7);
				{
				{
				setState(466);
				match(DATETIME);
				setState(467);
				match(LPAREN);
				setState(468);
				((PrimitiveExpressionContext)_localctx).year = datePart();
				setState(469);
				match(COMMA);
				setState(470);
				((PrimitiveExpressionContext)_localctx).month = datePart();
				setState(471);
				match(COMMA);
				setState(472);
				((PrimitiveExpressionContext)_localctx).day = datePart();
				setState(480);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA) {
					{
					setState(473);
					match(COMMA);
					setState(474);
					((PrimitiveExpressionContext)_localctx).hour = datePart();
					setState(475);
					match(COMMA);
					setState(476);
					((PrimitiveExpressionContext)_localctx).minute = datePart();
					setState(477);
					match(COMMA);
					setState(478);
					((PrimitiveExpressionContext)_localctx).second = datePart();
					}
				}

				setState(482);
				match(RPAREN);
				}
				}
				break;
			case AMPERSAND:
				enterOuterAlt(_localctx, 8);
				{
				setState(484);
				parameter();
				}
				break;
			case TYPE:
				enterOuterAlt(_localctx, 9);
				{
				{
				setState(485);
				match(TYPE);
				setState(486);
				match(LPAREN);
				setState(492);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case ACCOUNTING_REGISTER_TYPE:
				case ACCUMULATION_REGISTER_TYPE:
				case BUSINESS_PROCESS_TYPE:
				case CALCULATION_REGISTER_TYPE:
				case CATALOG_TYPE:
				case CHART_OF_ACCOUNTS_TYPE:
				case CHART_OF_CALCULATION_TYPES_TYPE:
				case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
				case CONSTANT_TYPE:
				case DOCUMENT_TYPE:
				case DOCUMENT_JOURNAL_TYPE:
				case ENUM_TYPE:
				case EXCHANGE_PLAN_TYPE:
				case EXTERNAL_DATA_SOURCE_TYPE:
				case FILTER_CRITERION_TYPE:
				case INFORMATION_REGISTER_TYPE:
				case SEQUENCE_TYPE:
				case TASK_TYPE:
					{
					setState(487);
					mdo();
					}
					break;
				case STRING:
					{
					setState(488);
					match(STRING);
					}
					break;
				case BOOLEAN:
					{
					setState(489);
					match(BOOLEAN);
					}
					break;
				case DATE:
					{
					setState(490);
					match(DATE);
					}
					break;
				case NUMBER:
					{
					setState(491);
					match(NUMBER);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(494);
				match(RPAREN);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CaseExpressionContext extends BSLParserRuleContext {
		public ExpressionContext caseExp;
		public LogicalExpressionContext elseExp;
		public TerminalNode CASE() { return getToken(SDBLParser.CASE, 0); }
		public TerminalNode END() { return getToken(SDBLParser.END, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public List caseBranch() {
			return getRuleContexts(CaseBranchContext.class);
		}
		public CaseBranchContext caseBranch(int i) {
			return getRuleContext(CaseBranchContext.class,i);
		}
		public TerminalNode ELSE() { return getToken(SDBLParser.ELSE, 0); }
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public CaseExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterCaseExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitCaseExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitCaseExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseExpressionContext caseExpression() throws RecognitionException {
		CaseExpressionContext _localctx = new CaseExpressionContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_caseExpression);
		int _la;
		try {
			setState(529);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(497);
				match(CASE);
				setState(498);
				((CaseExpressionContext)_localctx).caseExp = expression(0);
				setState(500); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(499);
					caseBranch();
					}
					}
					setState(502); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==WHEN );
				setState(506);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==ELSE) {
					{
					setState(504);
					match(ELSE);
					setState(505);
					((CaseExpressionContext)_localctx).elseExp = logicalExpression();
					}
				}

				setState(508);
				match(END);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(510);
				match(CASE);
				setState(512); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(511);
					caseBranch();
					}
					}
					setState(514); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==WHEN );
				setState(518);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==ELSE) {
					{
					setState(516);
					match(ELSE);
					setState(517);
					((CaseExpressionContext)_localctx).elseExp = logicalExpression();
					}
				}

				setState(520);
				match(END);
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(522);
				caseBranch();
				setState(525);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==ELSE) {
					{
					setState(523);
					match(ELSE);
					setState(524);
					((CaseExpressionContext)_localctx).elseExp = logicalExpression();
					}
				}

				setState(527);
				match(END);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CaseBranchContext extends BSLParserRuleContext {
		public TerminalNode WHEN() { return getToken(SDBLParser.WHEN, 0); }
		public List logicalExpression() {
			return getRuleContexts(LogicalExpressionContext.class);
		}
		public LogicalExpressionContext logicalExpression(int i) {
			return getRuleContext(LogicalExpressionContext.class,i);
		}
		public TerminalNode THEN() { return getToken(SDBLParser.THEN, 0); }
		public CaseBranchContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseBranch; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterCaseBranch(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitCaseBranch(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitCaseBranch(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseBranchContext caseBranch() throws RecognitionException {
		CaseBranchContext _localctx = new CaseBranchContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_caseBranch);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(531);
			match(WHEN);
			setState(532);
			logicalExpression();
			setState(533);
			match(THEN);
			setState(534);
			logicalExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BracketExpressionContext extends BSLParserRuleContext {
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class,0);
		}
		public BracketExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bracketExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterBracketExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitBracketExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitBracketExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BracketExpressionContext bracketExpression() throws RecognitionException {
		BracketExpressionContext _localctx = new BracketExpressionContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_bracketExpression);
		try {
			setState(544);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(536);
				match(LPAREN);
				setState(537);
				expression(0);
				setState(538);
				match(RPAREN);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(540);
				match(LPAREN);
				setState(541);
				subquery();
				setState(542);
				match(RPAREN);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnaryExpressionContext extends BSLParserRuleContext {
		public SignContext sign() {
			return getRuleContext(SignContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaryExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterUnaryExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitUnaryExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitUnaryExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnaryExpressionContext unaryExpression() throws RecognitionException {
		UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_unaryExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(546);
			sign();
			setState(547);
			expression(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunctionCallContext extends BSLParserRuleContext {
		public IdentifierContext identifier;
		public List columnNames = new ArrayList();
		public AggregateFunctionsContext aggregateFunctions() {
			return getRuleContext(AggregateFunctionsContext.class,0);
		}
		public BuiltInFunctionsContext builtInFunctions() {
			return getRuleContext(BuiltInFunctionsContext.class,0);
		}
		public ValueFunctionContext valueFunction() {
			return getRuleContext(ValueFunctionContext.class,0);
		}
		public List DOT() { return getTokens(SDBLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(SDBLParser.DOT, i);
		}
		public List identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public CastFunctionContext castFunction() {
			return getRuleContext(CastFunctionContext.class,0);
		}
		public FunctionCallContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionCall; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterFunctionCall(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitFunctionCall(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitFunctionCall(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionCallContext functionCall() throws RecognitionException {
		FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_functionCall);
		try {
			int _alt;
			setState(567);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AVG:
			case COUNT:
			case MAX:
			case MIN:
			case SUM:
				enterOuterAlt(_localctx, 1);
				{
				setState(549);
				aggregateFunctions();
				}
				break;
			case ISNULL:
			case ACOS:
			case ASIN:
			case ATAN:
			case BEGINOFPERIOD:
			case COS:
			case DATEADD:
			case DATEDIFF:
			case DAY:
			case DAYOFYEAR:
			case ENDOFPERIOD:
			case EXP:
			case HOUR:
			case INT:
			case LOG:
			case LOG10:
			case LOWER:
			case MINUTE:
			case MONTH:
			case QUARTER:
			case PRESENTATION:
			case REFPRESENTATION:
			case POW:
			case ROUND:
			case SECOND:
			case SIN:
			case SQRT:
			case STOREDDATASIZE:
			case STRINGLENGTH:
			case STRFIND:
			case STRREPLACE:
			case SUBSTRING:
			case TAN:
			case TRIMALL:
			case TRIML:
			case TRIMR:
			case UPPER:
			case VALUETYPE:
			case WEEK:
			case WEEKDAY:
			case YEAR:
			case UUID:
			case GROUPEDBY:
				enterOuterAlt(_localctx, 2);
				{
				setState(550);
				builtInFunctions();
				}
				break;
			case VALUE:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(551);
				valueFunction();
				setState(556);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(552);
						match(DOT);
						setState(553);
						((FunctionCallContext)_localctx).identifier = identifier();
						((FunctionCallContext)_localctx).columnNames.add(((FunctionCallContext)_localctx).identifier);
						}
						} 
					}
					setState(558);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
				}
				}
				}
				break;
			case CAST:
				enterOuterAlt(_localctx, 4);
				{
				{
				setState(559);
				castFunction();
				setState(564);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(560);
						match(DOT);
						setState(561);
						((FunctionCallContext)_localctx).identifier = identifier();
						((FunctionCallContext)_localctx).columnNames.add(((FunctionCallContext)_localctx).identifier);
						}
						} 
					}
					setState(566);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
				}
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BuiltInFunctionsContext extends BSLParserRuleContext {
		public Token doCall;
		public ExpressionContext string;
		public ExpressionContext charNo;
		public ExpressionContext count;
		public ExpressionContext date;
		public Token periodType;
		public ExpressionContext firstdate;
		public ExpressionContext seconddate;
		public ExpressionContext value;
		public LogicalExpressionContext first;
		public LogicalExpressionContext second;
		public ExpressionContext decimal;
		public ExpressionContext precise;
		public ExpressionContext substring1;
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode SUBSTRING() { return getToken(SDBLParser.SUBSTRING, 0); }
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode YEAR() { return getToken(SDBLParser.YEAR, 0); }
		public TerminalNode QUARTER() { return getToken(SDBLParser.QUARTER, 0); }
		public TerminalNode MONTH() { return getToken(SDBLParser.MONTH, 0); }
		public TerminalNode DAYOFYEAR() { return getToken(SDBLParser.DAYOFYEAR, 0); }
		public TerminalNode DAY() { return getToken(SDBLParser.DAY, 0); }
		public TerminalNode WEEK() { return getToken(SDBLParser.WEEK, 0); }
		public TerminalNode WEEKDAY() { return getToken(SDBLParser.WEEKDAY, 0); }
		public TerminalNode HOUR() { return getToken(SDBLParser.HOUR, 0); }
		public TerminalNode MINUTE() { return getToken(SDBLParser.MINUTE, 0); }
		public TerminalNode SECOND() { return getToken(SDBLParser.SECOND, 0); }
		public TerminalNode BEGINOFPERIOD() { return getToken(SDBLParser.BEGINOFPERIOD, 0); }
		public TerminalNode ENDOFPERIOD() { return getToken(SDBLParser.ENDOFPERIOD, 0); }
		public TerminalNode TENDAYS() { return getToken(SDBLParser.TENDAYS, 0); }
		public TerminalNode HALFYEAR() { return getToken(SDBLParser.HALFYEAR, 0); }
		public TerminalNode DATEADD() { return getToken(SDBLParser.DATEADD, 0); }
		public TerminalNode DATEDIFF() { return getToken(SDBLParser.DATEDIFF, 0); }
		public TerminalNode VALUETYPE() { return getToken(SDBLParser.VALUETYPE, 0); }
		public TerminalNode PRESENTATION() { return getToken(SDBLParser.PRESENTATION, 0); }
		public TerminalNode REFPRESENTATION() { return getToken(SDBLParser.REFPRESENTATION, 0); }
		public TerminalNode GROUPEDBY() { return getToken(SDBLParser.GROUPEDBY, 0); }
		public TerminalNode ISNULL() { return getToken(SDBLParser.ISNULL, 0); }
		public List logicalExpression() {
			return getRuleContexts(LogicalExpressionContext.class);
		}
		public LogicalExpressionContext logicalExpression(int i) {
			return getRuleContext(LogicalExpressionContext.class,i);
		}
		public TerminalNode ACOS() { return getToken(SDBLParser.ACOS, 0); }
		public TerminalNode ASIN() { return getToken(SDBLParser.ASIN, 0); }
		public TerminalNode ATAN() { return getToken(SDBLParser.ATAN, 0); }
		public TerminalNode COS() { return getToken(SDBLParser.COS, 0); }
		public TerminalNode SIN() { return getToken(SDBLParser.SIN, 0); }
		public TerminalNode TAN() { return getToken(SDBLParser.TAN, 0); }
		public TerminalNode LOG() { return getToken(SDBLParser.LOG, 0); }
		public TerminalNode LOG10() { return getToken(SDBLParser.LOG10, 0); }
		public TerminalNode EXP() { return getToken(SDBLParser.EXP, 0); }
		public TerminalNode POW() { return getToken(SDBLParser.POW, 0); }
		public TerminalNode SQRT() { return getToken(SDBLParser.SQRT, 0); }
		public TerminalNode INT() { return getToken(SDBLParser.INT, 0); }
		public TerminalNode LOWER() { return getToken(SDBLParser.LOWER, 0); }
		public TerminalNode STRINGLENGTH() { return getToken(SDBLParser.STRINGLENGTH, 0); }
		public TerminalNode TRIMALL() { return getToken(SDBLParser.TRIMALL, 0); }
		public TerminalNode TRIML() { return getToken(SDBLParser.TRIML, 0); }
		public TerminalNode TRIMR() { return getToken(SDBLParser.TRIMR, 0); }
		public TerminalNode UPPER() { return getToken(SDBLParser.UPPER, 0); }
		public TerminalNode ROUND() { return getToken(SDBLParser.ROUND, 0); }
		public TerminalNode STOREDDATASIZE() { return getToken(SDBLParser.STOREDDATASIZE, 0); }
		public TerminalNode UUID() { return getToken(SDBLParser.UUID, 0); }
		public TerminalNode STRFIND() { return getToken(SDBLParser.STRFIND, 0); }
		public TerminalNode STRREPLACE() { return getToken(SDBLParser.STRREPLACE, 0); }
		public BuiltInFunctionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_builtInFunctions; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterBuiltInFunctions(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitBuiltInFunctions(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitBuiltInFunctions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BuiltInFunctionsContext builtInFunctions() throws RecognitionException {
		BuiltInFunctionsContext _localctx = new BuiltInFunctionsContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_builtInFunctions);
		int _la;
		try {
			setState(658);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SUBSTRING:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(569);
				((BuiltInFunctionsContext)_localctx).doCall = match(SUBSTRING);
				setState(570);
				match(LPAREN);
				setState(571);
				((BuiltInFunctionsContext)_localctx).string = expression(0);
				setState(572);
				match(COMMA);
				setState(573);
				((BuiltInFunctionsContext)_localctx).charNo = expression(0);
				setState(574);
				match(COMMA);
				setState(575);
				((BuiltInFunctionsContext)_localctx).count = expression(0);
				setState(576);
				match(RPAREN);
				}
				}
				break;
			case DAY:
			case DAYOFYEAR:
			case HOUR:
			case MINUTE:
			case MONTH:
			case QUARTER:
			case SECOND:
			case WEEK:
			case WEEKDAY:
			case YEAR:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(578);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 246290671911043L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(579);
				match(LPAREN);
				setState(580);
				((BuiltInFunctionsContext)_localctx).date = expression(0);
				setState(581);
				match(RPAREN);
				}
				}
				break;
			case BEGINOFPERIOD:
			case ENDOFPERIOD:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(583);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(_la==BEGINOFPERIOD || _la==ENDOFPERIOD) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(584);
				match(LPAREN);
				setState(585);
				((BuiltInFunctionsContext)_localctx).date = expression(0);
				setState(586);
				match(COMMA);
				setState(587);
				((BuiltInFunctionsContext)_localctx).periodType = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 176059299578049L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).periodType = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(588);
				match(RPAREN);
				}
				}
				break;
			case DATEADD:
				enterOuterAlt(_localctx, 4);
				{
				{
				setState(590);
				((BuiltInFunctionsContext)_localctx).doCall = match(DATEADD);
				setState(591);
				match(LPAREN);
				setState(592);
				((BuiltInFunctionsContext)_localctx).date = expression(0);
				setState(593);
				match(COMMA);
				setState(594);
				((BuiltInFunctionsContext)_localctx).periodType = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 176059366686913L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).periodType = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(595);
				match(COMMA);
				setState(596);
				((BuiltInFunctionsContext)_localctx).count = expression(0);
				setState(597);
				match(RPAREN);
				}
				}
				break;
			case DATEDIFF:
				enterOuterAlt(_localctx, 5);
				{
				{
				setState(599);
				((BuiltInFunctionsContext)_localctx).doCall = match(DATEDIFF);
				setState(600);
				match(LPAREN);
				setState(601);
				((BuiltInFunctionsContext)_localctx).firstdate = expression(0);
				setState(602);
				match(COMMA);
				setState(603);
				((BuiltInFunctionsContext)_localctx).seconddate = expression(0);
				setState(604);
				match(COMMA);
				setState(605);
				((BuiltInFunctionsContext)_localctx).periodType = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 140737555644545L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).periodType = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(606);
				match(RPAREN);
				}
				}
				break;
			case PRESENTATION:
			case REFPRESENTATION:
			case VALUETYPE:
			case GROUPEDBY:
				enterOuterAlt(_localctx, 6);
				{
				{
				setState(608);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & 1125899915231237L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(609);
				match(LPAREN);
				setState(610);
				((BuiltInFunctionsContext)_localctx).value = expression(0);
				setState(611);
				match(RPAREN);
				}
				}
				break;
			case ISNULL:
				enterOuterAlt(_localctx, 7);
				{
				{
				setState(613);
				((BuiltInFunctionsContext)_localctx).doCall = match(ISNULL);
				setState(614);
				match(LPAREN);
				setState(615);
				((BuiltInFunctionsContext)_localctx).first = logicalExpression();
				setState(616);
				match(COMMA);
				setState(617);
				((BuiltInFunctionsContext)_localctx).second = logicalExpression();
				setState(618);
				match(RPAREN);
				}
				}
				break;
			case ACOS:
			case ASIN:
			case ATAN:
			case COS:
			case EXP:
			case INT:
			case LOG:
			case LOG10:
			case POW:
			case SIN:
			case SQRT:
			case TAN:
				enterOuterAlt(_localctx, 8);
				{
				{
				setState(620);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & 283192971100231L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(621);
				match(LPAREN);
				setState(622);
				((BuiltInFunctionsContext)_localctx).decimal = expression(0);
				setState(623);
				match(RPAREN);
				}
				}
				break;
			case LOWER:
			case STRINGLENGTH:
			case TRIMALL:
			case TRIML:
			case TRIMR:
			case UPPER:
				enterOuterAlt(_localctx, 9);
				{
				{
				setState(625);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 3088056321L) != 0)) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(626);
				match(LPAREN);
				setState(627);
				((BuiltInFunctionsContext)_localctx).string = expression(0);
				setState(628);
				match(RPAREN);
				}
				}
				break;
			case ROUND:
				enterOuterAlt(_localctx, 10);
				{
				{
				setState(630);
				((BuiltInFunctionsContext)_localctx).doCall = match(ROUND);
				setState(631);
				match(LPAREN);
				setState(632);
				((BuiltInFunctionsContext)_localctx).decimal = expression(0);
				setState(633);
				match(COMMA);
				setState(634);
				((BuiltInFunctionsContext)_localctx).precise = expression(0);
				setState(635);
				match(RPAREN);
				}
				}
				break;
			case STOREDDATASIZE:
			case UUID:
				enterOuterAlt(_localctx, 11);
				{
				{
				setState(637);
				((BuiltInFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(_la==STOREDDATASIZE || _la==UUID) ) {
					((BuiltInFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(638);
				match(LPAREN);
				setState(639);
				((BuiltInFunctionsContext)_localctx).value = expression(0);
				setState(640);
				match(RPAREN);
				}
				}
				break;
			case STRFIND:
				enterOuterAlt(_localctx, 12);
				{
				{
				setState(642);
				((BuiltInFunctionsContext)_localctx).doCall = match(STRFIND);
				setState(643);
				match(LPAREN);
				setState(644);
				((BuiltInFunctionsContext)_localctx).string = expression(0);
				setState(645);
				match(COMMA);
				setState(646);
				((BuiltInFunctionsContext)_localctx).substring1 = expression(0);
				setState(647);
				match(RPAREN);
				}
				}
				break;
			case STRREPLACE:
				enterOuterAlt(_localctx, 13);
				{
				{
				setState(649);
				((BuiltInFunctionsContext)_localctx).doCall = match(STRREPLACE);
				setState(650);
				match(LPAREN);
				setState(651);
				((BuiltInFunctionsContext)_localctx).string = expression(0);
				setState(652);
				match(COMMA);
				setState(653);
				((BuiltInFunctionsContext)_localctx).substring1 = expression(0);
				setState(654);
				match(COMMA);
				setState(655);
				((BuiltInFunctionsContext)_localctx).substring1 = expression(0);
				setState(656);
				match(RPAREN);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AggregateFunctionsContext extends BSLParserRuleContext {
		public Token doCall;
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode SUM() { return getToken(SDBLParser.SUM, 0); }
		public TerminalNode AVG() { return getToken(SDBLParser.AVG, 0); }
		public TerminalNode MIN() { return getToken(SDBLParser.MIN, 0); }
		public TerminalNode MAX() { return getToken(SDBLParser.MAX, 0); }
		public TerminalNode COUNT() { return getToken(SDBLParser.COUNT, 0); }
		public TerminalNode MUL() { return getToken(SDBLParser.MUL, 0); }
		public TerminalNode DISTINCT() { return getToken(SDBLParser.DISTINCT, 0); }
		public AggregateFunctionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aggregateFunctions; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterAggregateFunctions(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitAggregateFunctions(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitAggregateFunctions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AggregateFunctionsContext aggregateFunctions() throws RecognitionException {
		AggregateFunctionsContext _localctx = new AggregateFunctionsContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_aggregateFunctions);
		int _la;
		try {
			setState(675);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AVG:
			case MAX:
			case MIN:
			case SUM:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(660);
				((AggregateFunctionsContext)_localctx).doCall = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 61)) & ~0x3f) == 0 && ((1L << (_la - 61)) & 17592192335873L) != 0)) ) {
					((AggregateFunctionsContext)_localctx).doCall = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(661);
				match(LPAREN);
				setState(662);
				logicalExpression();
				setState(663);
				match(RPAREN);
				}
				}
				break;
			case COUNT:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(665);
				((AggregateFunctionsContext)_localctx).doCall = match(COUNT);
				setState(666);
				match(LPAREN);
				setState(672);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case LPAREN:
				case PLUS:
				case MINUS:
				case AMPERSAND:
				case CASE:
				case CAST:
				case DISTINCT:
				case DROP:
				case END:
				case FALSE:
				case ISNULL:
				case NOT:
				case NULL:
				case SELECT:
				case TOTALS:
				case TRUE:
				case UNDEFINED:
				case WHEN:
				case ACOS:
				case ASIN:
				case ATAN:
				case AVG:
				case BEGINOFPERIOD:
				case BOOLEAN:
				case COS:
				case COUNT:
				case DATE:
				case DATEADD:
				case DATEDIFF:
				case DATETIME:
				case DAY:
				case DAYOFYEAR:
				case EMPTYTABLE:
				case EMPTYREF:
				case ENDOFPERIOD:
				case EXP:
				case HALFYEAR:
				case HOUR:
				case INT:
				case LOG:
				case LOG10:
				case LOWER:
				case MAX:
				case MIN:
				case MINUTE:
				case MONTH:
				case NUMBER:
				case QUARTER:
				case ONLY:
				case PERIODS:
				case REFS:
				case PRESENTATION:
				case RECORDAUTONUMBER:
				case REFPRESENTATION:
				case POW:
				case ROUND:
				case SECOND:
				case SIN:
				case SQRT:
				case STOREDDATASIZE:
				case STRING:
				case STRINGLENGTH:
				case STRFIND:
				case STRREPLACE:
				case SUBSTRING:
				case SUM:
				case TAN:
				case TENDAYS:
				case TRIMALL:
				case TRIML:
				case TRIMR:
				case TYPE:
				case UPPER:
				case VALUE:
				case VALUETYPE:
				case WEEK:
				case WEEKDAY:
				case YEAR:
				case UUID:
				case ACCOUNTING_REGISTER_TYPE:
				case ACCUMULATION_REGISTER_TYPE:
				case BUSINESS_PROCESS_TYPE:
				case CALCULATION_REGISTER_TYPE:
				case CATALOG_TYPE:
				case CHART_OF_ACCOUNTS_TYPE:
				case CHART_OF_CALCULATION_TYPES_TYPE:
				case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
				case CONSTANT_TYPE:
				case DOCUMENT_TYPE:
				case DOCUMENT_JOURNAL_TYPE:
				case ENUM_TYPE:
				case EXCHANGE_PLAN_TYPE:
				case EXTERNAL_DATA_SOURCE_TYPE:
				case FILTER_CRITERION_TYPE:
				case INFORMATION_REGISTER_TYPE:
				case SEQUENCE_TYPE:
				case TASK_TYPE:
				case ROUTEPOINT_FIELD:
				case INDEX:
				case GROUP:
				case ORDER:
				case GROUPEDBY:
				case SET:
				case RIGHT:
				case LEFT:
				case INNER:
				case FULL:
				case JOIN:
				case OUTER:
				case FOR:
				case UPDATE:
				case ALL:
				case UNION:
				case DECIMAL:
				case FLOAT:
				case STR:
				case IDENTIFIER:
				case ACTUAL_ACTION_PERIOD_VT:
				case BALANCE_VT:
				case BALANCE_AND_TURNOVERS_VT:
				case BOUNDARIES_VT:
				case DR_CR_TURNOVERS_VT:
				case EXT_DIMENSIONS_VT:
				case RECORDS_WITH_EXT_DIMENSIONS_VT:
				case SCHEDULE_DATA_VT:
				case SLICEFIRST_VT:
				case SLICELAST_VT:
				case TASK_BY_PERFORMER_VT:
				case TURNOVERS_VT:
					{
					setState(668);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==DISTINCT) {
						{
						setState(667);
						match(DISTINCT);
						}
					}

					setState(670);
					logicalExpression();
					}
					break;
				case MUL:
					{
					setState(671);
					match(MUL);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(674);
				match(RPAREN);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ValueFunctionContext extends BSLParserRuleContext {
		public Token doCall;
		public Token type;
		public IdentifierContext mdoName;
		public Token emptyFer;
		public IdentifierContext predefinedName;
		public IdentifierContext routePointName;
		public IdentifierContext systemName;
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public TerminalNode VALUE() { return getToken(SDBLParser.VALUE, 0); }
		public List DOT() { return getTokens(SDBLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(SDBLParser.DOT, i);
		}
		public TerminalNode ROUTEPOINT_FIELD() { return getToken(SDBLParser.ROUTEPOINT_FIELD, 0); }
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public List identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public TerminalNode EMPTYREF() { return getToken(SDBLParser.EMPTYREF, 0); }
		public TerminalNode BUSINESS_PROCESS_TYPE() { return getToken(SDBLParser.BUSINESS_PROCESS_TYPE, 0); }
		public TerminalNode CATALOG_TYPE() { return getToken(SDBLParser.CATALOG_TYPE, 0); }
		public TerminalNode DOCUMENT_TYPE() { return getToken(SDBLParser.DOCUMENT_TYPE, 0); }
		public TerminalNode FILTER_CRITERION_TYPE() { return getToken(SDBLParser.FILTER_CRITERION_TYPE, 0); }
		public TerminalNode EXCHANGE_PLAN_TYPE() { return getToken(SDBLParser.EXCHANGE_PLAN_TYPE, 0); }
		public TerminalNode ENUM_TYPE() { return getToken(SDBLParser.ENUM_TYPE, 0); }
		public TerminalNode CHART_OF_CHARACTERISTIC_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CHARACTERISTIC_TYPES_TYPE, 0); }
		public TerminalNode CHART_OF_ACCOUNTS_TYPE() { return getToken(SDBLParser.CHART_OF_ACCOUNTS_TYPE, 0); }
		public TerminalNode CHART_OF_CALCULATION_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CALCULATION_TYPES_TYPE, 0); }
		public TerminalNode TASK_TYPE() { return getToken(SDBLParser.TASK_TYPE, 0); }
		public TerminalNode EXTERNAL_DATA_SOURCE_TYPE() { return getToken(SDBLParser.EXTERNAL_DATA_SOURCE_TYPE, 0); }
		public ValueFunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_valueFunction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterValueFunction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitValueFunction(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitValueFunction(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueFunctionContext valueFunction() throws RecognitionException {
		ValueFunctionContext _localctx = new ValueFunctionContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_valueFunction);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(677);
			((ValueFunctionContext)_localctx).doCall = match(VALUE);
			setState(678);
			match(LPAREN);
			setState(706);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
			case 1:
				{
				{
				setState(679);
				((ValueFunctionContext)_localctx).type = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & 40637L) != 0)) ) {
					((ValueFunctionContext)_localctx).type = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(680);
				match(DOT);
				setState(681);
				((ValueFunctionContext)_localctx).mdoName = identifier();
				setState(682);
				match(DOT);
				setState(683);
				((ValueFunctionContext)_localctx).emptyFer = match(EMPTYREF);
				}
				}
				break;
			case 2:
				{
				{
				setState(685);
				((ValueFunctionContext)_localctx).type = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 143L) != 0)) ) {
					((ValueFunctionContext)_localctx).type = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(686);
				match(DOT);
				setState(687);
				((ValueFunctionContext)_localctx).mdoName = identifier();
				setState(688);
				match(DOT);
				setState(689);
				((ValueFunctionContext)_localctx).predefinedName = identifier();
				}
				}
				break;
			case 3:
				{
				{
				setState(691);
				((ValueFunctionContext)_localctx).type = match(BUSINESS_PROCESS_TYPE);
				setState(692);
				match(DOT);
				setState(693);
				((ValueFunctionContext)_localctx).mdoName = identifier();
				setState(694);
				match(DOT);
				setState(695);
				match(ROUTEPOINT_FIELD);
				setState(696);
				match(DOT);
				setState(697);
				((ValueFunctionContext)_localctx).routePointName = identifier();
				}
				}
				break;
			case 4:
				{
				{
				setState(699);
				((ValueFunctionContext)_localctx).systemName = identifier();
				setState(700);
				match(DOT);
				setState(701);
				((ValueFunctionContext)_localctx).predefinedName = identifier();
				}
				}
				break;
			case 5:
				{
				{
				setState(703);
				mdo();
				setState(704);
				match(DOT);
				}
				}
				break;
			}
			setState(708);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CastFunctionContext extends BSLParserRuleContext {
		public Token doCall;
		public ExpressionContext value;
		public Token type;
		public Token len;
		public Token prec;
		public List LPAREN() { return getTokens(SDBLParser.LPAREN); }
		public TerminalNode LPAREN(int i) {
			return getToken(SDBLParser.LPAREN, i);
		}
		public TerminalNode AS() { return getToken(SDBLParser.AS, 0); }
		public List RPAREN() { return getTokens(SDBLParser.RPAREN); }
		public TerminalNode RPAREN(int i) {
			return getToken(SDBLParser.RPAREN, i);
		}
		public TerminalNode CAST() { return getToken(SDBLParser.CAST, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public TerminalNode BOOLEAN() { return getToken(SDBLParser.BOOLEAN, 0); }
		public TerminalNode DATE() { return getToken(SDBLParser.DATE, 0); }
		public TerminalNode NUMBER() { return getToken(SDBLParser.NUMBER, 0); }
		public TerminalNode STRING() { return getToken(SDBLParser.STRING, 0); }
		public List DECIMAL() { return getTokens(SDBLParser.DECIMAL); }
		public TerminalNode DECIMAL(int i) {
			return getToken(SDBLParser.DECIMAL, i);
		}
		public TerminalNode COMMA() { return getToken(SDBLParser.COMMA, 0); }
		public CastFunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_castFunction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterCastFunction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitCastFunction(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitCastFunction(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CastFunctionContext castFunction() throws RecognitionException {
		CastFunctionContext _localctx = new CastFunctionContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_castFunction);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(710);
			((CastFunctionContext)_localctx).doCall = match(CAST);
			setState(711);
			match(LPAREN);
			setState(712);
			((CastFunctionContext)_localctx).value = expression(0);
			setState(713);
			match(AS);
			setState(733);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case BOOLEAN:
				{
				setState(714);
				((CastFunctionContext)_localctx).type = match(BOOLEAN);
				}
				break;
			case NUMBER:
				{
				{
				setState(715);
				((CastFunctionContext)_localctx).type = match(NUMBER);
				setState(723);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LPAREN) {
					{
					setState(716);
					match(LPAREN);
					setState(717);
					((CastFunctionContext)_localctx).len = match(DECIMAL);
					setState(720);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==COMMA) {
						{
						setState(718);
						match(COMMA);
						setState(719);
						((CastFunctionContext)_localctx).prec = match(DECIMAL);
						}
					}

					setState(722);
					match(RPAREN);
					}
				}

				}
				}
				break;
			case STRING:
				{
				{
				setState(725);
				((CastFunctionContext)_localctx).type = match(STRING);
				setState(729);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LPAREN) {
					{
					setState(726);
					match(LPAREN);
					setState(727);
					((CastFunctionContext)_localctx).len = match(DECIMAL);
					setState(728);
					match(RPAREN);
					}
				}

				}
				}
				break;
			case DATE:
				{
				setState(731);
				((CastFunctionContext)_localctx).type = match(DATE);
				}
				break;
			case ACCOUNTING_REGISTER_TYPE:
			case ACCUMULATION_REGISTER_TYPE:
			case BUSINESS_PROCESS_TYPE:
			case CALCULATION_REGISTER_TYPE:
			case CATALOG_TYPE:
			case CHART_OF_ACCOUNTS_TYPE:
			case CHART_OF_CALCULATION_TYPES_TYPE:
			case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
			case CONSTANT_TYPE:
			case DOCUMENT_TYPE:
			case DOCUMENT_JOURNAL_TYPE:
			case ENUM_TYPE:
			case EXCHANGE_PLAN_TYPE:
			case EXTERNAL_DATA_SOURCE_TYPE:
			case FILTER_CRITERION_TYPE:
			case INFORMATION_REGISTER_TYPE:
			case SEQUENCE_TYPE:
			case TASK_TYPE:
				{
				setState(732);
				mdo();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(735);
			match(RPAREN);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LogicalExpressionContext extends BSLParserRuleContext {
		public PredicateContext predicate;
		public List condidions = new ArrayList();
		public List predicate() {
			return getRuleContexts(PredicateContext.class);
		}
		public PredicateContext predicate(int i) {
			return getRuleContext(PredicateContext.class,i);
		}
		public List AND() { return getTokens(SDBLParser.AND); }
		public TerminalNode AND(int i) {
			return getToken(SDBLParser.AND, i);
		}
		public List OR() { return getTokens(SDBLParser.OR); }
		public TerminalNode OR(int i) {
			return getToken(SDBLParser.OR, i);
		}
		public LogicalExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterLogicalExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitLogicalExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitLogicalExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicalExpressionContext logicalExpression() throws RecognitionException {
		LogicalExpressionContext _localctx = new LogicalExpressionContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_logicalExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(737);
			((LogicalExpressionContext)_localctx).predicate = predicate();
			((LogicalExpressionContext)_localctx).condidions.add(((LogicalExpressionContext)_localctx).predicate);
			setState(742);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==AND || _la==OR) {
				{
				{
				setState(738);
				_la = _input.LA(1);
				if ( !(_la==AND || _la==OR) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(739);
				((LogicalExpressionContext)_localctx).predicate = predicate();
				((LogicalExpressionContext)_localctx).condidions.add(((LogicalExpressionContext)_localctx).predicate);
				}
				}
				setState(744);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PredicateContext extends BSLParserRuleContext {
		public ExpressionContext booleanPredicate;
		public LikePredicateContext likePredicate() {
			return getRuleContext(LikePredicateContext.class,0);
		}
		public IsNullPredicateContext isNullPredicate() {
			return getRuleContext(IsNullPredicateContext.class,0);
		}
		public ComparePredicateContext comparePredicate() {
			return getRuleContext(ComparePredicateContext.class,0);
		}
		public BetweenPredicateContext betweenPredicate() {
			return getRuleContext(BetweenPredicateContext.class,0);
		}
		public InPredicateContext inPredicate() {
			return getRuleContext(InPredicateContext.class,0);
		}
		public RefsPredicateContext refsPredicate() {
			return getRuleContext(RefsPredicateContext.class,0);
		}
		public List NOT() { return getTokens(SDBLParser.NOT); }
		public TerminalNode NOT(int i) {
			return getToken(SDBLParser.NOT, i);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public PredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_predicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterPredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitPredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitPredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PredicateContext predicate() throws RecognitionException {
		PredicateContext _localctx = new PredicateContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_predicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(748);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==NOT) {
				{
				{
				setState(745);
				match(NOT);
				}
				}
				setState(750);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(762);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
			case 1:
				{
				setState(751);
				((PredicateContext)_localctx).booleanPredicate = expression(0);
				}
				break;
			case 2:
				{
				setState(752);
				likePredicate();
				}
				break;
			case 3:
				{
				setState(753);
				isNullPredicate();
				}
				break;
			case 4:
				{
				setState(754);
				comparePredicate();
				}
				break;
			case 5:
				{
				setState(755);
				betweenPredicate();
				}
				break;
			case 6:
				{
				setState(756);
				inPredicate();
				}
				break;
			case 7:
				{
				setState(757);
				refsPredicate();
				}
				break;
			case 8:
				{
				{
				setState(758);
				match(LPAREN);
				setState(759);
				logicalExpression();
				setState(760);
				match(RPAREN);
				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LikePredicateContext extends BSLParserRuleContext {
		public MultiStringContext escape;
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode LIKE() { return getToken(SDBLParser.LIKE, 0); }
		public List NOT() { return getTokens(SDBLParser.NOT); }
		public TerminalNode NOT(int i) {
			return getToken(SDBLParser.NOT, i);
		}
		public TerminalNode ESCAPE() { return getToken(SDBLParser.ESCAPE, 0); }
		public MultiStringContext multiString() {
			return getRuleContext(MultiStringContext.class,0);
		}
		public LikePredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_likePredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterLikePredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitLikePredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitLikePredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LikePredicateContext likePredicate() throws RecognitionException {
		LikePredicateContext _localctx = new LikePredicateContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_likePredicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(764);
			expression(0);
			setState(768);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==NOT) {
				{
				{
				setState(765);
				match(NOT);
				}
				}
				setState(770);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(771);
			match(LIKE);
			setState(772);
			expression(0);
			setState(775);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ESCAPE) {
				{
				setState(773);
				match(ESCAPE);
				setState(774);
				((LikePredicateContext)_localctx).escape = multiString();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IsNullPredicateContext extends BSLParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode IS() { return getToken(SDBLParser.IS, 0); }
		public TerminalNode NULL() { return getToken(SDBLParser.NULL, 0); }
		public TerminalNode NOT() { return getToken(SDBLParser.NOT, 0); }
		public IsNullPredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_isNullPredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterIsNullPredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitIsNullPredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitIsNullPredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IsNullPredicateContext isNullPredicate() throws RecognitionException {
		IsNullPredicateContext _localctx = new IsNullPredicateContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_isNullPredicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(777);
			expression(0);
			setState(778);
			match(IS);
			setState(780);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==NOT) {
				{
				setState(779);
				match(NOT);
				}
			}

			setState(782);
			match(NULL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ComparePredicateContext extends BSLParserRuleContext {
		public Token compareOperation;
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode LESS() { return getToken(SDBLParser.LESS, 0); }
		public TerminalNode LESS_OR_EQUAL() { return getToken(SDBLParser.LESS_OR_EQUAL, 0); }
		public TerminalNode GREATER() { return getToken(SDBLParser.GREATER, 0); }
		public TerminalNode GREATER_OR_EQUAL() { return getToken(SDBLParser.GREATER_OR_EQUAL, 0); }
		public TerminalNode ASSIGN() { return getToken(SDBLParser.ASSIGN, 0); }
		public TerminalNode NOT_EQUAL() { return getToken(SDBLParser.NOT_EQUAL, 0); }
		public ComparePredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_comparePredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterComparePredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitComparePredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitComparePredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ComparePredicateContext comparePredicate() throws RecognitionException {
		ComparePredicateContext _localctx = new ComparePredicateContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_comparePredicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(784);
			expression(0);
			setState(785);
			((ComparePredicateContext)_localctx).compareOperation = _input.LT(1);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 63744L) != 0)) ) {
				((ComparePredicateContext)_localctx).compareOperation = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(786);
			expression(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BetweenPredicateContext extends BSLParserRuleContext {
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode BETWEEN() { return getToken(SDBLParser.BETWEEN, 0); }
		public TerminalNode AND() { return getToken(SDBLParser.AND, 0); }
		public BetweenPredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_betweenPredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterBetweenPredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitBetweenPredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitBetweenPredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BetweenPredicateContext betweenPredicate() throws RecognitionException {
		BetweenPredicateContext _localctx = new BetweenPredicateContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_betweenPredicate);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(788);
			expression(0);
			setState(789);
			match(BETWEEN);
			setState(790);
			expression(0);
			setState(791);
			match(AND);
			setState(792);
			expression(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InPredicateContext extends BSLParserRuleContext {
		public TerminalNode IN() { return getToken(SDBLParser.IN, 0); }
		public List LPAREN() { return getTokens(SDBLParser.LPAREN); }
		public TerminalNode LPAREN(int i) {
			return getToken(SDBLParser.LPAREN, i);
		}
		public List RPAREN() { return getTokens(SDBLParser.RPAREN); }
		public TerminalNode RPAREN(int i) {
			return getToken(SDBLParser.RPAREN, i);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class,0);
		}
		public List expressionList() {
			return getRuleContexts(ExpressionListContext.class);
		}
		public ExpressionListContext expressionList(int i) {
			return getRuleContext(ExpressionListContext.class,i);
		}
		public List NOT() { return getTokens(SDBLParser.NOT); }
		public TerminalNode NOT(int i) {
			return getToken(SDBLParser.NOT, i);
		}
		public TerminalNode HIERARCHY_FOR_IN() { return getToken(SDBLParser.HIERARCHY_FOR_IN, 0); }
		public InPredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inPredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterInPredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitInPredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitInPredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InPredicateContext inPredicate() throws RecognitionException {
		InPredicateContext _localctx = new InPredicateContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_inPredicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(799);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
			case 1:
				{
				setState(794);
				expression(0);
				}
				break;
			case 2:
				{
				{
				setState(795);
				match(LPAREN);
				setState(796);
				expressionList();
				setState(797);
				match(RPAREN);
				}
				}
				break;
			}
			setState(804);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==NOT) {
				{
				{
				setState(801);
				match(NOT);
				}
				}
				setState(806);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(807);
			match(IN);
			setState(809);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==HIERARCHY_FOR_IN) {
				{
				setState(808);
				match(HIERARCHY_FOR_IN);
				}
			}

			setState(811);
			match(LPAREN);
			setState(814);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
			case 1:
				{
				setState(812);
				subquery();
				}
				break;
			case 2:
				{
				setState(813);
				expressionList();
				}
				break;
			}
			setState(816);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RefsPredicateContext extends BSLParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode REFS() { return getToken(SDBLParser.REFS, 0); }
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public RefsPredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_refsPredicate; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterRefsPredicate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitRefsPredicate(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitRefsPredicate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RefsPredicateContext refsPredicate() throws RecognitionException {
		RefsPredicateContext _localctx = new RefsPredicateContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_refsPredicate);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(818);
			expression(0);
			setState(819);
			match(REFS);
			setState(820);
			mdo();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionListContext extends BSLParserRuleContext {
		public LogicalExpressionContext logicalExpression;
		public List exp = new ArrayList();
		public List logicalExpression() {
			return getRuleContexts(LogicalExpressionContext.class);
		}
		public LogicalExpressionContext logicalExpression(int i) {
			return getRuleContext(LogicalExpressionContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public ExpressionListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterExpressionList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitExpressionList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitExpressionList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionListContext expressionList() throws RecognitionException {
		ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_expressionList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(822);
			((ExpressionListContext)_localctx).logicalExpression = logicalExpression();
			((ExpressionListContext)_localctx).exp.add(((ExpressionListContext)_localctx).logicalExpression);
			setState(827);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(823);
				match(COMMA);
				setState(824);
				((ExpressionListContext)_localctx).logicalExpression = logicalExpression();
				((ExpressionListContext)_localctx).exp.add(((ExpressionListContext)_localctx).logicalExpression);
				}
				}
				setState(829);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DataSourcesContext extends BSLParserRuleContext {
		public DataSourceContext dataSource;
		public List tables = new ArrayList();
		public List dataSource() {
			return getRuleContexts(DataSourceContext.class);
		}
		public DataSourceContext dataSource(int i) {
			return getRuleContext(DataSourceContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public DataSourcesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dataSources; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterDataSources(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitDataSources(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitDataSources(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DataSourcesContext dataSources() throws RecognitionException {
		DataSourcesContext _localctx = new DataSourcesContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_dataSources);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(830);
			((DataSourcesContext)_localctx).dataSource = dataSource();
			((DataSourcesContext)_localctx).tables.add(((DataSourcesContext)_localctx).dataSource);
			setState(835);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(831);
				match(COMMA);
				setState(832);
				((DataSourcesContext)_localctx).dataSource = dataSource();
				((DataSourcesContext)_localctx).tables.add(((DataSourcesContext)_localctx).dataSource);
				}
				}
				setState(837);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DataSourceContext extends BSLParserRuleContext {
		public JoinPartContext joinPart;
		public List joins = new ArrayList();
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public DataSourceContext dataSource() {
			return getRuleContext(DataSourceContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public List joinPart() {
			return getRuleContexts(JoinPartContext.class);
		}
		public JoinPartContext joinPart(int i) {
			return getRuleContext(JoinPartContext.class,i);
		}
		public VirtualTableContext virtualTable() {
			return getRuleContext(VirtualTableContext.class,0);
		}
		public TableContext table() {
			return getRuleContext(TableContext.class,0);
		}
		public ParameterTableContext parameterTable() {
			return getRuleContext(ParameterTableContext.class,0);
		}
		public ExternalDataSourceTableContext externalDataSourceTable() {
			return getRuleContext(ExternalDataSourceTableContext.class,0);
		}
		public SubqueryContext subquery() {
			return getRuleContext(SubqueryContext.class,0);
		}
		public AliasContext alias() {
			return getRuleContext(AliasContext.class,0);
		}
		public DataSourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dataSource; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterDataSource(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitDataSource(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitDataSource(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DataSourceContext dataSource() throws RecognitionException {
		DataSourceContext _localctx = new DataSourceContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_dataSource);
		int _la;
		try {
			setState(870);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(838);
				match(LPAREN);
				setState(839);
				dataSource();
				setState(840);
				match(RPAREN);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(862);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case AMPERSAND:
				case DROP:
				case END:
				case ISNULL:
				case SELECT:
				case TOTALS:
				case ACOS:
				case ASIN:
				case ATAN:
				case AVG:
				case BEGINOFPERIOD:
				case BOOLEAN:
				case COS:
				case COUNT:
				case DATE:
				case DATEADD:
				case DATEDIFF:
				case DATETIME:
				case DAY:
				case DAYOFYEAR:
				case EMPTYTABLE:
				case EMPTYREF:
				case ENDOFPERIOD:
				case EXP:
				case HALFYEAR:
				case HOUR:
				case INT:
				case LOG:
				case LOG10:
				case LOWER:
				case MAX:
				case MIN:
				case MINUTE:
				case MONTH:
				case NUMBER:
				case QUARTER:
				case ONLY:
				case PERIODS:
				case REFS:
				case PRESENTATION:
				case RECORDAUTONUMBER:
				case REFPRESENTATION:
				case POW:
				case ROUND:
				case SECOND:
				case SIN:
				case SQRT:
				case STOREDDATASIZE:
				case STRING:
				case STRINGLENGTH:
				case STRFIND:
				case STRREPLACE:
				case SUBSTRING:
				case SUM:
				case TAN:
				case TENDAYS:
				case TRIMALL:
				case TRIML:
				case TRIMR:
				case TYPE:
				case UPPER:
				case VALUE:
				case VALUETYPE:
				case WEEK:
				case WEEKDAY:
				case YEAR:
				case UUID:
				case ACCOUNTING_REGISTER_TYPE:
				case ACCUMULATION_REGISTER_TYPE:
				case BUSINESS_PROCESS_TYPE:
				case CALCULATION_REGISTER_TYPE:
				case CATALOG_TYPE:
				case CHART_OF_ACCOUNTS_TYPE:
				case CHART_OF_CALCULATION_TYPES_TYPE:
				case CHART_OF_CHARACTERISTIC_TYPES_TYPE:
				case CONSTANT_TYPE:
				case DOCUMENT_TYPE:
				case DOCUMENT_JOURNAL_TYPE:
				case ENUM_TYPE:
				case EXCHANGE_PLAN_TYPE:
				case EXTERNAL_DATA_SOURCE_TYPE:
				case FILTER_CRITERION_TYPE:
				case INFORMATION_REGISTER_TYPE:
				case SEQUENCE_TYPE:
				case TASK_TYPE:
				case ROUTEPOINT_FIELD:
				case INDEX:
				case GROUP:
				case ORDER:
				case SET:
				case RIGHT:
				case LEFT:
				case INNER:
				case FULL:
				case JOIN:
				case OUTER:
				case FOR:
				case UPDATE:
				case ALL:
				case UNION:
				case IDENTIFIER:
				case ACTUAL_ACTION_PERIOD_VT:
				case BALANCE_VT:
				case BALANCE_AND_TURNOVERS_VT:
				case BOUNDARIES_VT:
				case DR_CR_TURNOVERS_VT:
				case EXT_DIMENSIONS_VT:
				case RECORDS_WITH_EXT_DIMENSIONS_VT:
				case SCHEDULE_DATA_VT:
				case SLICEFIRST_VT:
				case SLICELAST_VT:
				case TASK_BY_PERFORMER_VT:
				case TURNOVERS_VT:
					{
					{
					setState(846);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
					case 1:
						{
						setState(842);
						virtualTable();
						}
						break;
					case 2:
						{
						setState(843);
						table();
						}
						break;
					case 3:
						{
						setState(844);
						parameterTable();
						}
						break;
					case 4:
						{
						setState(845);
						externalDataSourceTable();
						}
						break;
					}
					setState(849);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
					case 1:
						{
						setState(848);
						alias();
						}
						break;
					}
					}
					}
					break;
				case LPAREN:
					{
					{
					setState(851);
					match(LPAREN);
					setState(856);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
					case 1:
						{
						setState(852);
						virtualTable();
						}
						break;
					case 2:
						{
						setState(853);
						table();
						}
						break;
					case 3:
						{
						setState(854);
						parameterTable();
						}
						break;
					case 4:
						{
						setState(855);
						subquery();
						}
						break;
					}
					setState(858);
					match(RPAREN);
					setState(860);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
					case 1:
						{
						setState(859);
						alias();
						}
						break;
					}
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(867);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (((((_la - 144)) & ~0x3f) == 0 && ((1L << (_la - 144)) & 31L) != 0)) {
					{
					{
					setState(864);
					((DataSourceContext)_localctx).joinPart = joinPart();
					((DataSourceContext)_localctx).joins.add(((DataSourceContext)_localctx).joinPart);
					}
					}
					setState(869);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TableContext extends BSLParserRuleContext {
		public IdentifierContext objectTableName;
		public IdentifierContext tableName;
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public TerminalNode DOT() { return getToken(SDBLParser.DOT, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitTable(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitTable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TableContext table() throws RecognitionException {
		TableContext _localctx = new TableContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_table);
		try {
			setState(878);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(872);
				mdo();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(873);
				mdo();
				setState(874);
				match(DOT);
				setState(875);
				((TableContext)_localctx).objectTableName = identifier();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(877);
				((TableContext)_localctx).tableName = identifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class VirtualTableContext extends BSLParserRuleContext {
		public Token virtualTableName;
		public VirtualTableParameterContext virtualTableParameter;
		public List virtualTableParameters = new ArrayList();
		public Token type;
		public IdentifierContext tableName;
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public TerminalNode DOT() { return getToken(SDBLParser.DOT, 0); }
		public TerminalNode SLICELAST_VT() { return getToken(SDBLParser.SLICELAST_VT, 0); }
		public TerminalNode SLICEFIRST_VT() { return getToken(SDBLParser.SLICEFIRST_VT, 0); }
		public TerminalNode BOUNDARIES_VT() { return getToken(SDBLParser.BOUNDARIES_VT, 0); }
		public TerminalNode TURNOVERS_VT() { return getToken(SDBLParser.TURNOVERS_VT, 0); }
		public TerminalNode BALANCE_VT() { return getToken(SDBLParser.BALANCE_VT, 0); }
		public TerminalNode BALANCE_AND_TURNOVERS_VT() { return getToken(SDBLParser.BALANCE_AND_TURNOVERS_VT, 0); }
		public TerminalNode EXT_DIMENSIONS_VT() { return getToken(SDBLParser.EXT_DIMENSIONS_VT, 0); }
		public TerminalNode RECORDS_WITH_EXT_DIMENSIONS_VT() { return getToken(SDBLParser.RECORDS_WITH_EXT_DIMENSIONS_VT, 0); }
		public TerminalNode DR_CR_TURNOVERS_VT() { return getToken(SDBLParser.DR_CR_TURNOVERS_VT, 0); }
		public TerminalNode ACTUAL_ACTION_PERIOD_VT() { return getToken(SDBLParser.ACTUAL_ACTION_PERIOD_VT, 0); }
		public TerminalNode SCHEDULE_DATA_VT() { return getToken(SDBLParser.SCHEDULE_DATA_VT, 0); }
		public TerminalNode TASK_BY_PERFORMER_VT() { return getToken(SDBLParser.TASK_BY_PERFORMER_VT, 0); }
		public TerminalNode LPAREN() { return getToken(SDBLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(SDBLParser.RPAREN, 0); }
		public List virtualTableParameter() {
			return getRuleContexts(VirtualTableParameterContext.class);
		}
		public VirtualTableParameterContext virtualTableParameter(int i) {
			return getRuleContext(VirtualTableParameterContext.class,i);
		}
		public List COMMA() { return getTokens(SDBLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(SDBLParser.COMMA, i);
		}
		public TerminalNode FILTER_CRITERION_TYPE() { return getToken(SDBLParser.FILTER_CRITERION_TYPE, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public ParameterContext parameter() {
			return getRuleContext(ParameterContext.class,0);
		}
		public VirtualTableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_virtualTable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterVirtualTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitVirtualTable(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitVirtualTable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VirtualTableContext virtualTable() throws RecognitionException {
		VirtualTableContext _localctx = new VirtualTableContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_virtualTable);
		int _la;
		try {
			setState(905);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(880);
				mdo();
				setState(881);
				match(DOT);
				setState(882);
				((VirtualTableContext)_localctx).virtualTableName = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 163)) & ~0x3f) == 0 && ((1L << (_la - 163)) & 4095L) != 0)) ) {
					((VirtualTableContext)_localctx).virtualTableName = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(894);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LPAREN) {
					{
					setState(883);
					match(LPAREN);
					setState(884);
					((VirtualTableContext)_localctx).virtualTableParameter = virtualTableParameter();
					((VirtualTableContext)_localctx).virtualTableParameters.add(((VirtualTableContext)_localctx).virtualTableParameter);
					setState(889);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(885);
						match(COMMA);
						setState(886);
						((VirtualTableContext)_localctx).virtualTableParameter = virtualTableParameter();
						((VirtualTableContext)_localctx).virtualTableParameters.add(((VirtualTableContext)_localctx).virtualTableParameter);
						}
						}
						setState(891);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(892);
					match(RPAREN);
					}
				}

				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(896);
				((VirtualTableContext)_localctx).type = match(FILTER_CRITERION_TYPE);
				setState(897);
				match(DOT);
				setState(898);
				((VirtualTableContext)_localctx).tableName = identifier();
				setState(899);
				match(LPAREN);
				setState(901);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==AMPERSAND) {
					{
					setState(900);
					parameter();
					}
				}

				setState(903);
				match(RPAREN);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class VirtualTableParameterContext extends BSLParserRuleContext {
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public VirtualTableParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_virtualTableParameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterVirtualTableParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitVirtualTableParameter(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitVirtualTableParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VirtualTableParameterContext virtualTableParameter() throws RecognitionException {
		VirtualTableParameterContext _localctx = new VirtualTableParameterContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_virtualTableParameter);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(908);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -151967854621358576L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 140709369724927L) != 0)) {
				{
				setState(907);
				logicalExpression();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterTableContext extends BSLParserRuleContext {
		public ParameterContext parameter() {
			return getRuleContext(ParameterContext.class,0);
		}
		public ParameterTableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterTable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterParameterTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitParameterTable(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitParameterTable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParameterTableContext parameterTable() throws RecognitionException {
		ParameterTableContext _localctx = new ParameterTableContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_parameterTable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(910);
			parameter();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExternalDataSourceTableContext extends BSLParserRuleContext {
		public IdentifierContext tableName;
		public IdentifierContext cubeName;
		public MdoContext mdo() {
			return getRuleContext(MdoContext.class,0);
		}
		public List DOT() { return getTokens(SDBLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(SDBLParser.DOT, i);
		}
		public TerminalNode EDS_TABLE() { return getToken(SDBLParser.EDS_TABLE, 0); }
		public List identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public TerminalNode EDS_CUBE() { return getToken(SDBLParser.EDS_CUBE, 0); }
		public TerminalNode EDS_CUBE_DIMTABLE() { return getToken(SDBLParser.EDS_CUBE_DIMTABLE, 0); }
		public ExternalDataSourceTableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_externalDataSourceTable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterExternalDataSourceTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitExternalDataSourceTable(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitExternalDataSourceTable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExternalDataSourceTableContext externalDataSourceTable() throws RecognitionException {
		ExternalDataSourceTableContext _localctx = new ExternalDataSourceTableContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_externalDataSourceTable);
		try {
			setState(928);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(912);
				mdo();
				setState(913);
				match(DOT);
				setState(914);
				match(EDS_TABLE);
				setState(915);
				match(DOT);
				setState(916);
				((ExternalDataSourceTableContext)_localctx).tableName = identifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(918);
				mdo();
				setState(919);
				match(DOT);
				setState(920);
				match(EDS_CUBE);
				setState(921);
				match(DOT);
				setState(922);
				((ExternalDataSourceTableContext)_localctx).cubeName = identifier();
				setState(923);
				match(DOT);
				setState(924);
				match(EDS_CUBE_DIMTABLE);
				setState(925);
				match(DOT);
				setState(926);
				((ExternalDataSourceTableContext)_localctx).tableName = identifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class JoinPartContext extends BSLParserRuleContext {
		public Token joinType;
		public Token outerJoin;
		public DataSourceContext source;
		public LogicalExpressionContext condition;
		public DataSourceContext dataSource() {
			return getRuleContext(DataSourceContext.class,0);
		}
		public TerminalNode ON_EN() { return getToken(SDBLParser.ON_EN, 0); }
		public TerminalNode PO_RU() { return getToken(SDBLParser.PO_RU, 0); }
		public LogicalExpressionContext logicalExpression() {
			return getRuleContext(LogicalExpressionContext.class,0);
		}
		public TerminalNode JOIN() { return getToken(SDBLParser.JOIN, 0); }
		public TerminalNode RIGHT() { return getToken(SDBLParser.RIGHT, 0); }
		public TerminalNode LEFT() { return getToken(SDBLParser.LEFT, 0); }
		public TerminalNode FULL() { return getToken(SDBLParser.FULL, 0); }
		public TerminalNode INNER() { return getToken(SDBLParser.INNER, 0); }
		public TerminalNode OUTER() { return getToken(SDBLParser.OUTER, 0); }
		public JoinPartContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_joinPart; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterJoinPart(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitJoinPart(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitJoinPart(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JoinPartContext joinPart() throws RecognitionException {
		JoinPartContext _localctx = new JoinPartContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_joinPart);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(948);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case RIGHT:
				{
				{
				setState(930);
				((JoinPartContext)_localctx).joinType = match(RIGHT);
				setState(932);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==OUTER) {
					{
					setState(931);
					((JoinPartContext)_localctx).outerJoin = match(OUTER);
					}
				}

				setState(934);
				match(JOIN);
				}
				}
				break;
			case LEFT:
				{
				{
				setState(935);
				((JoinPartContext)_localctx).joinType = match(LEFT);
				setState(937);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==OUTER) {
					{
					setState(936);
					((JoinPartContext)_localctx).outerJoin = match(OUTER);
					}
				}

				setState(939);
				match(JOIN);
				}
				}
				break;
			case FULL:
				{
				{
				setState(940);
				((JoinPartContext)_localctx).joinType = match(FULL);
				setState(942);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==OUTER) {
					{
					setState(941);
					((JoinPartContext)_localctx).outerJoin = match(OUTER);
					}
				}

				setState(944);
				match(JOIN);
				}
				}
				break;
			case INNER:
				{
				{
				setState(945);
				((JoinPartContext)_localctx).joinType = match(INNER);
				setState(946);
				match(JOIN);
				}
				}
				break;
			case JOIN:
				{
				{
				setState(947);
				((JoinPartContext)_localctx).joinType = match(JOIN);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(950);
			((JoinPartContext)_localctx).source = dataSource();
			setState(951);
			_la = _input.LA(1);
			if ( !(_la==ON_EN || _la==PO_RU) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(952);
			((JoinPartContext)_localctx).condition = logicalExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AliasContext extends BSLParserRuleContext {
		public IdentifierContext name;
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode AS() { return getToken(SDBLParser.AS, 0); }
		public AliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alias; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterAlias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitAlias(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitAlias(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AliasContext alias() throws RecognitionException {
		AliasContext _localctx = new AliasContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_alias);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(955);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AS) {
				{
				setState(954);
				match(AS);
				}
			}

			setState(957);
			((AliasContext)_localctx).name = identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DatePartContext extends BSLParserRuleContext {
		public ParameterContext parameter() {
			return getRuleContext(ParameterContext.class,0);
		}
		public TerminalNode DECIMAL() { return getToken(SDBLParser.DECIMAL, 0); }
		public DatePartContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_datePart; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterDatePart(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitDatePart(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitDatePart(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DatePartContext datePart() throws RecognitionException {
		DatePartContext _localctx = new DatePartContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_datePart);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(961);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AMPERSAND:
				{
				setState(959);
				parameter();
				}
				break;
			case DECIMAL:
				{
				setState(960);
				match(DECIMAL);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MultiStringContext extends BSLParserRuleContext {
		public List STR() { return getTokens(SDBLParser.STR); }
		public TerminalNode STR(int i) {
			return getToken(SDBLParser.STR, i);
		}
		public MultiStringContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_multiString; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterMultiString(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitMultiString(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitMultiString(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MultiStringContext multiString() throws RecognitionException {
		MultiStringContext _localctx = new MultiStringContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_multiString);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(964); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(963);
					match(STR);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(966); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,104,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SignContext extends BSLParserRuleContext {
		public TerminalNode MINUS() { return getToken(SDBLParser.MINUS, 0); }
		public TerminalNode PLUS() { return getToken(SDBLParser.PLUS, 0); }
		public SignContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sign; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterSign(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitSign(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitSign(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SignContext sign() throws RecognitionException {
		SignContext _localctx = new SignContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_sign);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(968);
			_la = _input.LA(1);
			if ( !(_la==PLUS || _la==MINUS) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdentifierContext extends BSLParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(SDBLParser.IDENTIFIER, 0); }
		public TerminalNode ACTUAL_ACTION_PERIOD_VT() { return getToken(SDBLParser.ACTUAL_ACTION_PERIOD_VT, 0); }
		public TerminalNode BALANCE_VT() { return getToken(SDBLParser.BALANCE_VT, 0); }
		public TerminalNode BALANCE_AND_TURNOVERS_VT() { return getToken(SDBLParser.BALANCE_AND_TURNOVERS_VT, 0); }
		public TerminalNode BOUNDARIES_VT() { return getToken(SDBLParser.BOUNDARIES_VT, 0); }
		public TerminalNode DR_CR_TURNOVERS_VT() { return getToken(SDBLParser.DR_CR_TURNOVERS_VT, 0); }
		public TerminalNode EXT_DIMENSIONS_VT() { return getToken(SDBLParser.EXT_DIMENSIONS_VT, 0); }
		public TerminalNode RECORDS_WITH_EXT_DIMENSIONS_VT() { return getToken(SDBLParser.RECORDS_WITH_EXT_DIMENSIONS_VT, 0); }
		public TerminalNode SCHEDULE_DATA_VT() { return getToken(SDBLParser.SCHEDULE_DATA_VT, 0); }
		public TerminalNode SLICEFIRST_VT() { return getToken(SDBLParser.SLICEFIRST_VT, 0); }
		public TerminalNode SLICELAST_VT() { return getToken(SDBLParser.SLICELAST_VT, 0); }
		public TerminalNode TASK_BY_PERFORMER_VT() { return getToken(SDBLParser.TASK_BY_PERFORMER_VT, 0); }
		public TerminalNode TURNOVERS_VT() { return getToken(SDBLParser.TURNOVERS_VT, 0); }
		public TerminalNode ROUTEPOINT_FIELD() { return getToken(SDBLParser.ROUTEPOINT_FIELD, 0); }
		public TerminalNode BUSINESS_PROCESS_TYPE() { return getToken(SDBLParser.BUSINESS_PROCESS_TYPE, 0); }
		public TerminalNode CATALOG_TYPE() { return getToken(SDBLParser.CATALOG_TYPE, 0); }
		public TerminalNode DOCUMENT_TYPE() { return getToken(SDBLParser.DOCUMENT_TYPE, 0); }
		public TerminalNode INFORMATION_REGISTER_TYPE() { return getToken(SDBLParser.INFORMATION_REGISTER_TYPE, 0); }
		public TerminalNode CONSTANT_TYPE() { return getToken(SDBLParser.CONSTANT_TYPE, 0); }
		public TerminalNode FILTER_CRITERION_TYPE() { return getToken(SDBLParser.FILTER_CRITERION_TYPE, 0); }
		public TerminalNode EXCHANGE_PLAN_TYPE() { return getToken(SDBLParser.EXCHANGE_PLAN_TYPE, 0); }
		public TerminalNode SEQUENCE_TYPE() { return getToken(SDBLParser.SEQUENCE_TYPE, 0); }
		public TerminalNode DOCUMENT_JOURNAL_TYPE() { return getToken(SDBLParser.DOCUMENT_JOURNAL_TYPE, 0); }
		public TerminalNode ENUM_TYPE() { return getToken(SDBLParser.ENUM_TYPE, 0); }
		public TerminalNode CHART_OF_CHARACTERISTIC_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CHARACTERISTIC_TYPES_TYPE, 0); }
		public TerminalNode CHART_OF_ACCOUNTS_TYPE() { return getToken(SDBLParser.CHART_OF_ACCOUNTS_TYPE, 0); }
		public TerminalNode CHART_OF_CALCULATION_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CALCULATION_TYPES_TYPE, 0); }
		public TerminalNode ACCUMULATION_REGISTER_TYPE() { return getToken(SDBLParser.ACCUMULATION_REGISTER_TYPE, 0); }
		public TerminalNode ACCOUNTING_REGISTER_TYPE() { return getToken(SDBLParser.ACCOUNTING_REGISTER_TYPE, 0); }
		public TerminalNode CALCULATION_REGISTER_TYPE() { return getToken(SDBLParser.CALCULATION_REGISTER_TYPE, 0); }
		public TerminalNode TASK_TYPE() { return getToken(SDBLParser.TASK_TYPE, 0); }
		public TerminalNode EXTERNAL_DATA_SOURCE_TYPE() { return getToken(SDBLParser.EXTERNAL_DATA_SOURCE_TYPE, 0); }
		public TerminalNode DROP() { return getToken(SDBLParser.DROP, 0); }
		public TerminalNode END() { return getToken(SDBLParser.END, 0); }
		public TerminalNode ISNULL() { return getToken(SDBLParser.ISNULL, 0); }
		public TerminalNode JOIN() { return getToken(SDBLParser.JOIN, 0); }
		public TerminalNode SELECT() { return getToken(SDBLParser.SELECT, 0); }
		public TerminalNode TOTALS() { return getToken(SDBLParser.TOTALS, 0); }
		public TerminalNode UNION() { return getToken(SDBLParser.UNION, 0); }
		public TerminalNode UPDATE() { return getToken(SDBLParser.UPDATE, 0); }
		public TerminalNode AVG() { return getToken(SDBLParser.AVG, 0); }
		public TerminalNode BEGINOFPERIOD() { return getToken(SDBLParser.BEGINOFPERIOD, 0); }
		public TerminalNode BOOLEAN() { return getToken(SDBLParser.BOOLEAN, 0); }
		public TerminalNode COUNT() { return getToken(SDBLParser.COUNT, 0); }
		public TerminalNode DATE() { return getToken(SDBLParser.DATE, 0); }
		public TerminalNode DATEADD() { return getToken(SDBLParser.DATEADD, 0); }
		public TerminalNode DATEDIFF() { return getToken(SDBLParser.DATEDIFF, 0); }
		public TerminalNode DATETIME() { return getToken(SDBLParser.DATETIME, 0); }
		public TerminalNode DAY() { return getToken(SDBLParser.DAY, 0); }
		public TerminalNode DAYOFYEAR() { return getToken(SDBLParser.DAYOFYEAR, 0); }
		public TerminalNode EMPTYTABLE() { return getToken(SDBLParser.EMPTYTABLE, 0); }
		public TerminalNode EMPTYREF() { return getToken(SDBLParser.EMPTYREF, 0); }
		public TerminalNode ENDOFPERIOD() { return getToken(SDBLParser.ENDOFPERIOD, 0); }
		public TerminalNode HALFYEAR() { return getToken(SDBLParser.HALFYEAR, 0); }
		public TerminalNode HOUR() { return getToken(SDBLParser.HOUR, 0); }
		public TerminalNode MAX() { return getToken(SDBLParser.MAX, 0); }
		public TerminalNode MIN() { return getToken(SDBLParser.MIN, 0); }
		public TerminalNode MINUTE() { return getToken(SDBLParser.MINUTE, 0); }
		public TerminalNode MONTH() { return getToken(SDBLParser.MONTH, 0); }
		public TerminalNode NUMBER() { return getToken(SDBLParser.NUMBER, 0); }
		public TerminalNode QUARTER() { return getToken(SDBLParser.QUARTER, 0); }
		public TerminalNode ONLY() { return getToken(SDBLParser.ONLY, 0); }
		public TerminalNode PERIODS() { return getToken(SDBLParser.PERIODS, 0); }
		public TerminalNode REFS() { return getToken(SDBLParser.REFS, 0); }
		public TerminalNode PRESENTATION() { return getToken(SDBLParser.PRESENTATION, 0); }
		public TerminalNode RECORDAUTONUMBER() { return getToken(SDBLParser.RECORDAUTONUMBER, 0); }
		public TerminalNode REFPRESENTATION() { return getToken(SDBLParser.REFPRESENTATION, 0); }
		public TerminalNode SECOND() { return getToken(SDBLParser.SECOND, 0); }
		public TerminalNode STRING() { return getToken(SDBLParser.STRING, 0); }
		public TerminalNode SUBSTRING() { return getToken(SDBLParser.SUBSTRING, 0); }
		public TerminalNode SUM() { return getToken(SDBLParser.SUM, 0); }
		public TerminalNode TENDAYS() { return getToken(SDBLParser.TENDAYS, 0); }
		public TerminalNode TYPE() { return getToken(SDBLParser.TYPE, 0); }
		public TerminalNode VALUE() { return getToken(SDBLParser.VALUE, 0); }
		public TerminalNode VALUETYPE() { return getToken(SDBLParser.VALUETYPE, 0); }
		public TerminalNode WEEK() { return getToken(SDBLParser.WEEK, 0); }
		public TerminalNode WEEKDAY() { return getToken(SDBLParser.WEEKDAY, 0); }
		public TerminalNode YEAR() { return getToken(SDBLParser.YEAR, 0); }
		public TerminalNode ORDER() { return getToken(SDBLParser.ORDER, 0); }
		public TerminalNode GROUP() { return getToken(SDBLParser.GROUP, 0); }
		public TerminalNode INDEX() { return getToken(SDBLParser.INDEX, 0); }
		public TerminalNode SET() { return getToken(SDBLParser.SET, 0); }
		public TerminalNode RIGHT() { return getToken(SDBLParser.RIGHT, 0); }
		public TerminalNode LEFT() { return getToken(SDBLParser.LEFT, 0); }
		public TerminalNode INNER() { return getToken(SDBLParser.INNER, 0); }
		public TerminalNode FULL() { return getToken(SDBLParser.FULL, 0); }
		public TerminalNode OUTER() { return getToken(SDBLParser.OUTER, 0); }
		public TerminalNode FOR() { return getToken(SDBLParser.FOR, 0); }
		public TerminalNode ALL() { return getToken(SDBLParser.ALL, 0); }
		public TerminalNode ACOS() { return getToken(SDBLParser.ACOS, 0); }
		public TerminalNode ASIN() { return getToken(SDBLParser.ASIN, 0); }
		public TerminalNode ATAN() { return getToken(SDBLParser.ATAN, 0); }
		public TerminalNode COS() { return getToken(SDBLParser.COS, 0); }
		public TerminalNode SIN() { return getToken(SDBLParser.SIN, 0); }
		public TerminalNode TAN() { return getToken(SDBLParser.TAN, 0); }
		public TerminalNode LOG() { return getToken(SDBLParser.LOG, 0); }
		public TerminalNode LOG10() { return getToken(SDBLParser.LOG10, 0); }
		public TerminalNode EXP() { return getToken(SDBLParser.EXP, 0); }
		public TerminalNode POW() { return getToken(SDBLParser.POW, 0); }
		public TerminalNode SQRT() { return getToken(SDBLParser.SQRT, 0); }
		public TerminalNode INT() { return getToken(SDBLParser.INT, 0); }
		public TerminalNode LOWER() { return getToken(SDBLParser.LOWER, 0); }
		public TerminalNode STRINGLENGTH() { return getToken(SDBLParser.STRINGLENGTH, 0); }
		public TerminalNode TRIMALL() { return getToken(SDBLParser.TRIMALL, 0); }
		public TerminalNode TRIML() { return getToken(SDBLParser.TRIML, 0); }
		public TerminalNode TRIMR() { return getToken(SDBLParser.TRIMR, 0); }
		public TerminalNode UPPER() { return getToken(SDBLParser.UPPER, 0); }
		public TerminalNode ROUND() { return getToken(SDBLParser.ROUND, 0); }
		public TerminalNode STOREDDATASIZE() { return getToken(SDBLParser.STOREDDATASIZE, 0); }
		public TerminalNode UUID() { return getToken(SDBLParser.UUID, 0); }
		public TerminalNode STRFIND() { return getToken(SDBLParser.STRFIND, 0); }
		public TerminalNode STRREPLACE() { return getToken(SDBLParser.STRREPLACE, 0); }
		public IdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterIdentifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitIdentifier(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitIdentifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdentifierContext identifier() throws RecognitionException {
		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_identifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(970);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -278095067229454336L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 140707490668543L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterContext extends BSLParserRuleContext {
		public Token name;
		public TerminalNode AMPERSAND() { return getToken(SDBLParser.AMPERSAND, 0); }
		public TerminalNode PARAMETER_IDENTIFIER() { return getToken(SDBLParser.PARAMETER_IDENTIFIER, 0); }
		public ParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitParameter(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParameterContext parameter() throws RecognitionException {
		ParameterContext _localctx = new ParameterContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_parameter);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(972);
			match(AMPERSAND);
			setState(973);
			((ParameterContext)_localctx).name = match(PARAMETER_IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MdoContext extends BSLParserRuleContext {
		public Token type;
		public IdentifierContext tableName;
		public TerminalNode DOT() { return getToken(SDBLParser.DOT, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode BUSINESS_PROCESS_TYPE() { return getToken(SDBLParser.BUSINESS_PROCESS_TYPE, 0); }
		public TerminalNode CATALOG_TYPE() { return getToken(SDBLParser.CATALOG_TYPE, 0); }
		public TerminalNode DOCUMENT_TYPE() { return getToken(SDBLParser.DOCUMENT_TYPE, 0); }
		public TerminalNode INFORMATION_REGISTER_TYPE() { return getToken(SDBLParser.INFORMATION_REGISTER_TYPE, 0); }
		public TerminalNode CONSTANT_TYPE() { return getToken(SDBLParser.CONSTANT_TYPE, 0); }
		public TerminalNode FILTER_CRITERION_TYPE() { return getToken(SDBLParser.FILTER_CRITERION_TYPE, 0); }
		public TerminalNode EXCHANGE_PLAN_TYPE() { return getToken(SDBLParser.EXCHANGE_PLAN_TYPE, 0); }
		public TerminalNode SEQUENCE_TYPE() { return getToken(SDBLParser.SEQUENCE_TYPE, 0); }
		public TerminalNode DOCUMENT_JOURNAL_TYPE() { return getToken(SDBLParser.DOCUMENT_JOURNAL_TYPE, 0); }
		public TerminalNode ENUM_TYPE() { return getToken(SDBLParser.ENUM_TYPE, 0); }
		public TerminalNode CHART_OF_CHARACTERISTIC_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CHARACTERISTIC_TYPES_TYPE, 0); }
		public TerminalNode CHART_OF_ACCOUNTS_TYPE() { return getToken(SDBLParser.CHART_OF_ACCOUNTS_TYPE, 0); }
		public TerminalNode CHART_OF_CALCULATION_TYPES_TYPE() { return getToken(SDBLParser.CHART_OF_CALCULATION_TYPES_TYPE, 0); }
		public TerminalNode ACCUMULATION_REGISTER_TYPE() { return getToken(SDBLParser.ACCUMULATION_REGISTER_TYPE, 0); }
		public TerminalNode ACCOUNTING_REGISTER_TYPE() { return getToken(SDBLParser.ACCOUNTING_REGISTER_TYPE, 0); }
		public TerminalNode CALCULATION_REGISTER_TYPE() { return getToken(SDBLParser.CALCULATION_REGISTER_TYPE, 0); }
		public TerminalNode TASK_TYPE() { return getToken(SDBLParser.TASK_TYPE, 0); }
		public TerminalNode EXTERNAL_DATA_SOURCE_TYPE() { return getToken(SDBLParser.EXTERNAL_DATA_SOURCE_TYPE, 0); }
		public MdoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mdo; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).enterMdo(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SDBLParserListener ) ((SDBLParserListener)listener).exitMdo(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof SDBLParserVisitor ) return ((SDBLParserVisitor)visitor).visitMdo(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MdoContext mdo() throws RecognitionException {
		MdoContext _localctx = new MdoContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_mdo);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(975);
			((MdoContext)_localctx).type = _input.LT(1);
			_la = _input.LA(1);
			if ( !(((((_la - 119)) & ~0x3f) == 0 && ((1L << (_la - 119)) & 262143L) != 0)) ) {
				((MdoContext)_localctx).type = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(976);
			match(DOT);
			setState(977);
			((MdoContext)_localctx).tableName = identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 26:
			return expression_sempred((ExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 1);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001\u00b3\u03d4\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
		"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
		"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
		"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
		"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
		"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
		"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
		"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
		"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
		"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
		"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
		"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
		"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
		",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
		"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
		"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
		";\u0002<\u0007<\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000~\b\u0000"+
		"\n\u0000\f\u0000\u0081\t\u0000\u0001\u0000\u0003\u0000\u0084\b\u0000\u0001"+
		"\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001\u008a\b\u0001\u0001"+
		"\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
		"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
		"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
		"\u0003\u0003\u0003\u009f\b\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003"+
		"\u0003\u00a4\b\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u00a8\b\u0003"+
		"\u0003\u0003\u00aa\b\u0003\u0001\u0004\u0001\u0004\u0003\u0004\u00ae\b"+
		"\u0004\u0001\u0004\u0004\u0004\u00b1\b\u0004\u000b\u0004\f\u0004\u00b2"+
		"\u0003\u0004\u00b5\b\u0004\u0001\u0005\u0001\u0005\u0003\u0005\u00b9\b"+
		"\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u00bd\b\u0005\u0001\u0006\u0001"+
		"\u0006\u0003\u0006\u00c1\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003"+
		"\u0006\u00c6\b\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u00ca\b\u0006"+
		"\u0001\u0006\u0001\u0006\u0003\u0006\u00ce\b\u0006\u0001\u0006\u0001\u0006"+
		"\u0001\u0006\u0003\u0006\u00d3\b\u0006\u0001\u0006\u0001\u0006\u0003\u0006"+
		"\u00d7\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u00dc\b"+
		"\u0006\u0003\u0006\u00de\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
		"\u0006\u0001\u0006\u0005\u0006\u00e5\b\u0006\n\u0006\f\u0006\u00e8\t\u0006"+
		"\u0003\u0006\u00ea\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007"+
		"\u00ef\b\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0003\u0007\u0115\b\u0007\u0001\b\u0001\b\u0001\b\u0001\t"+
		"\u0001\t\u0001\t\u0005\t\u011d\b\t\n\t\f\t\u0120\t\t\u0001\n\u0001\n\u0001"+
		"\n\u0001\n\u0001\n\u0003\n\u0127\b\n\u0001\n\u0003\n\u012a\b\n\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0005\u000b\u012f\b\u000b\n\u000b\f\u000b\u0132"+
		"\t\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0003"+
		"\r\u013a\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
		"\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u0145\b\u000f"+
		"\n\u000f\f\u000f\u0148\t\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+
		"\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+
		"\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+
		"\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0005"+
		"\u0012\u015f\b\u0012\n\u0012\f\u0012\u0162\t\u0012\u0001\u0012\u0001\u0012"+
		"\u0001\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u0169\b\u0012\n\u0012"+
		"\f\u0012\u016c\t\u0012\u0003\u0012\u016e\b\u0012\u0001\u0013\u0001\u0013"+
		"\u0003\u0013\u0172\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+
		"\u0001\u0014\u0003\u0014\u0179\b\u0014\u0001\u0015\u0001\u0015\u0001\u0015"+
		"\u0001\u0015\u0003\u0015\u017f\b\u0015\u0003\u0015\u0181\b\u0015\u0001"+
		"\u0016\u0001\u0016\u0003\u0016\u0185\b\u0016\u0001\u0016\u0001\u0016\u0001"+
		"\u0016\u0001\u0016\u0005\u0016\u018b\b\u0016\n\u0016\f\u0016\u018e\t\u0016"+
		"\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u0193\b\u0017\u0001\u0017"+
		"\u0001\u0017\u0003\u0017\u0197\b\u0017\u0001\u0017\u0003\u0017\u019a\b"+
		"\u0017\u0003\u0017\u019c\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+
		"\u0018\u0001\u0018\u0003\u0018\u01a3\b\u0018\u0001\u0018\u0001\u0018\u0003"+
		"\u0018\u01a7\b\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001"+
		"\u0019\u0004\u0019\u01ae\b\u0019\u000b\u0019\f\u0019\u01af\u0001\u0019"+
		"\u0001\u0019\u0001\u0019\u0001\u0019\u0004\u0019\u01b6\b\u0019\u000b\u0019"+
		"\f\u0019\u01b7\u0003\u0019\u01ba\b\u0019\u0001\u001a\u0001\u001a\u0001"+
		"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u01c3"+
		"\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0005\u001a\u01c8\b\u001a"+
		"\n\u001a\f\u001a\u01cb\t\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
		"\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
		"\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
		"\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u01e1"+
		"\b\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
		"\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u01ed"+
		"\b\u001b\u0001\u001b\u0003\u001b\u01f0\b\u001b\u0001\u001c\u0001\u001c"+
		"\u0001\u001c\u0004\u001c\u01f5\b\u001c\u000b\u001c\f\u001c\u01f6\u0001"+
		"\u001c\u0001\u001c\u0003\u001c\u01fb\b\u001c\u0001\u001c\u0001\u001c\u0001"+
		"\u001c\u0001\u001c\u0004\u001c\u0201\b\u001c\u000b\u001c\f\u001c\u0202"+
		"\u0001\u001c\u0001\u001c\u0003\u001c\u0207\b\u001c\u0001\u001c\u0001\u001c"+
		"\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u020e\b\u001c\u0001\u001c"+
		"\u0001\u001c\u0003\u001c\u0212\b\u001c\u0001\u001d\u0001\u001d\u0001\u001d"+
		"\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
		"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0221\b\u001e"+
		"\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001"+
		" \u0005 \u022b\b \n \f \u022e\t \u0001 \u0001 \u0001 \u0005 \u0233\b "+
		"\n \f \u0236\t \u0003 \u0238\b \u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0003!\u0293\b!\u0001\"\u0001\"\u0001\"\u0001\""+
		"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u029d\b\"\u0001\"\u0001\"\u0003"+
		"\"\u02a1\b\"\u0001\"\u0003\"\u02a4\b\"\u0001#\u0001#\u0001#\u0001#\u0001"+
		"#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+
		"#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+
		"#\u0001#\u0001#\u0001#\u0001#\u0003#\u02c3\b#\u0001#\u0001#\u0001$\u0001"+
		"$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u02d1"+
		"\b$\u0001$\u0003$\u02d4\b$\u0001$\u0001$\u0001$\u0001$\u0003$\u02da\b"+
		"$\u0001$\u0001$\u0003$\u02de\b$\u0001$\u0001$\u0001%\u0001%\u0001%\u0005"+
		"%\u02e5\b%\n%\f%\u02e8\t%\u0001&\u0005&\u02eb\b&\n&\f&\u02ee\t&\u0001"+
		"&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+
		"&\u0003&\u02fb\b&\u0001\'\u0001\'\u0005\'\u02ff\b\'\n\'\f\'\u0302\t\'"+
		"\u0001\'\u0001\'\u0001\'\u0001\'\u0003\'\u0308\b\'\u0001(\u0001(\u0001"+
		"(\u0003(\u030d\b(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0001*\u0001"+
		"*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001+\u0003"+
		"+\u0320\b+\u0001+\u0005+\u0323\b+\n+\f+\u0326\t+\u0001+\u0001+\u0003+"+
		"\u032a\b+\u0001+\u0001+\u0001+\u0003+\u032f\b+\u0001+\u0001+\u0001,\u0001"+
		",\u0001,\u0001,\u0001-\u0001-\u0001-\u0005-\u033a\b-\n-\f-\u033d\t-\u0001"+
		".\u0001.\u0001.\u0005.\u0342\b.\n.\f.\u0345\t.\u0001/\u0001/\u0001/\u0001"+
		"/\u0001/\u0001/\u0001/\u0001/\u0003/\u034f\b/\u0001/\u0003/\u0352\b/\u0001"+
		"/\u0001/\u0001/\u0001/\u0001/\u0003/\u0359\b/\u0001/\u0001/\u0003/\u035d"+
		"\b/\u0003/\u035f\b/\u0001/\u0005/\u0362\b/\n/\f/\u0365\t/\u0003/\u0367"+
		"\b/\u00010\u00010\u00010\u00010\u00010\u00010\u00030\u036f\b0\u00011\u0001"+
		"1\u00011\u00011\u00011\u00011\u00011\u00051\u0378\b1\n1\f1\u037b\t1\u0001"+
		"1\u00011\u00031\u037f\b1\u00011\u00011\u00011\u00011\u00011\u00031\u0386"+
		"\b1\u00011\u00011\u00031\u038a\b1\u00012\u00032\u038d\b2\u00013\u0001"+
		"3\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+
		"4\u00014\u00014\u00014\u00014\u00014\u00014\u00034\u03a1\b4\u00015\u0001"+
		"5\u00035\u03a5\b5\u00015\u00015\u00015\u00035\u03aa\b5\u00015\u00015\u0001"+
		"5\u00035\u03af\b5\u00015\u00015\u00015\u00015\u00035\u03b5\b5\u00015\u0001"+
		"5\u00015\u00015\u00016\u00036\u03bc\b6\u00016\u00016\u00017\u00017\u0003"+
		"7\u03c2\b7\u00018\u00048\u03c5\b8\u000b8\f8\u03c6\u00019\u00019\u0001"+
		":\u0001:\u0001;\u0001;\u0001;\u0001<\u0001<\u0001<\u0001<\u0001<\u0000"+
		"\u00014=\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018"+
		"\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvx\u0000"+
		"\u0017\u0002\u0000\u001a\u001a11\u0002\u0000\u0017\u0017\u001d\u001d\b"+
		"\u0000FFLMTUWW``kkssuu\u0002\u0000\t\n\u0010\u0011\u0002\u0000##66\u0006"+
		"\u0000FGMMTUWW``su\u0002\u0000>>JJ\u0007\u0000FFLMTUWWkkssuu\u0006\u0000"+
		"FFMMTUWW``uu\u0004\u0000[[]]rr\u008d\u008d\u0007\u0000:<@@KKNP^^abjj\u0004"+
		"\u0000QQeelnpp\u0002\u0000ccvv\u0003\u0000==RSii\u0005\u0000yy{~\u0080"+
		"\u0080\u0082\u0085\u0088\u0088\u0002\u0000{~\u0082\u0082\u0002\u0000\u0015"+
		"\u0015//\u0002\u0000\b\b\u000b\u000f\u0001\u0000\u00a3\u00ae\u0002\u0000"+
		"..11\u0001\u0000\t\n\t\u0000\u001f\u001f!!))2255:\u008c\u008f\u0099\u00a0"+
		"\u00a0\u00a3\u00ae\u0001\u0000w\u0088\u0448\u0000z\u0001\u0000\u0000\u0000"+
		"\u0002\u0089\u0001\u0000\u0000\u0000\u0004\u008b\u0001\u0000\u0000\u0000"+
		"\u0006\u008e\u0001\u0000\u0000\u0000\b\u00ab\u0001\u0000\u0000\u0000\n"+
		"\u00b6\u0001\u0000\u0000\u0000\f\u00be\u0001\u0000\u0000\u0000\u000e\u0114"+
		"\u0001\u0000\u0000\u0000\u0010\u0116\u0001\u0000\u0000\u0000\u0012\u0119"+
		"\u0001\u0000\u0000\u0000\u0014\u0126\u0001\u0000\u0000\u0000\u0016\u0130"+
		"\u0001\u0000\u0000\u0000\u0018\u0135\u0001\u0000\u0000\u0000\u001a\u0139"+
		"\u0001\u0000\u0000\u0000\u001c\u013b\u0001\u0000\u0000\u0000\u001e\u0141"+
		"\u0001\u0000\u0000\u0000 \u0149\u0001\u0000\u0000\u0000\"\u014f\u0001"+
		"\u0000\u0000\u0000$\u016d\u0001\u0000\u0000\u0000&\u0171\u0001\u0000\u0000"+
		"\u0000(\u0173\u0001\u0000\u0000\u0000*\u017a\u0001\u0000\u0000\u0000,"+
		"\u0182\u0001\u0000\u0000\u0000.\u019b\u0001\u0000\u0000\u00000\u019d\u0001"+
		"\u0000\u0000\u00002\u01b9\u0001\u0000\u0000\u00004\u01c2\u0001\u0000\u0000"+
		"\u00006\u01ef\u0001\u0000\u0000\u00008\u0211\u0001\u0000\u0000\u0000:"+
		"\u0213\u0001\u0000\u0000\u0000<\u0220\u0001\u0000\u0000\u0000>\u0222\u0001"+
		"\u0000\u0000\u0000@\u0237\u0001\u0000\u0000\u0000B\u0292\u0001\u0000\u0000"+
		"\u0000D\u02a3\u0001\u0000\u0000\u0000F\u02a5\u0001\u0000\u0000\u0000H"+
		"\u02c6\u0001\u0000\u0000\u0000J\u02e1\u0001\u0000\u0000\u0000L\u02ec\u0001"+
		"\u0000\u0000\u0000N\u02fc\u0001\u0000\u0000\u0000P\u0309\u0001\u0000\u0000"+
		"\u0000R\u0310\u0001\u0000\u0000\u0000T\u0314\u0001\u0000\u0000\u0000V"+
		"\u031f\u0001\u0000\u0000\u0000X\u0332\u0001\u0000\u0000\u0000Z\u0336\u0001"+
		"\u0000\u0000\u0000\\\u033e\u0001\u0000\u0000\u0000^\u0366\u0001\u0000"+
		"\u0000\u0000`\u036e\u0001\u0000\u0000\u0000b\u0389\u0001\u0000\u0000\u0000"+
		"d\u038c\u0001\u0000\u0000\u0000f\u038e\u0001\u0000\u0000\u0000h\u03a0"+
		"\u0001\u0000\u0000\u0000j\u03b4\u0001\u0000\u0000\u0000l\u03bb\u0001\u0000"+
		"\u0000\u0000n\u03c1\u0001\u0000\u0000\u0000p\u03c4\u0001\u0000\u0000\u0000"+
		"r\u03c8\u0001\u0000\u0000\u0000t\u03ca\u0001\u0000\u0000\u0000v\u03cc"+
		"\u0001\u0000\u0000\u0000x\u03cf\u0001\u0000\u0000\u0000z\u007f\u0003\u0002"+
		"\u0001\u0000{|\u0005\u0006\u0000\u0000|~\u0003\u0002\u0001\u0000}{\u0001"+
		"\u0000\u0000\u0000~\u0081\u0001\u0000\u0000\u0000\u007f}\u0001\u0000\u0000"+
		"\u0000\u007f\u0080\u0001\u0000\u0000\u0000\u0080\u0083\u0001\u0000\u0000"+
		"\u0000\u0081\u007f\u0001\u0000\u0000\u0000\u0082\u0084\u0005\u0006\u0000"+
		"\u0000\u0083\u0082\u0001\u0000\u0000\u0000\u0083\u0084\u0001\u0000\u0000"+
		"\u0000\u0084\u0085\u0001\u0000\u0000\u0000\u0085\u0086\u0005\u0000\u0000"+
		"\u0001\u0086\u0001\u0001\u0000\u0000\u0000\u0087\u008a\u0003\u0006\u0003"+
		"\u0000\u0088\u008a\u0003\u0004\u0002\u0000\u0089\u0087\u0001\u0000\u0000"+
		"\u0000\u0089\u0088\u0001\u0000\u0000\u0000\u008a\u0003\u0001\u0000\u0000"+
		"\u0000\u008b\u008c\u0005\u001f\u0000\u0000\u008c\u008d\u0003t:\u0000\u008d"+
		"\u0005\u0001\u0000\u0000\u0000\u008e\u00a9\u0003\b\u0004\u0000\u008f\u0090"+
		"\u0005\u0018\u0000\u0000\u0090\u0091\u0003(\u0014\u0000\u0091\u0092\u0003"+
		",\u0016\u0000\u0092\u00aa\u0001\u0000\u0000\u0000\u0093\u0094\u0003(\u0014"+
		"\u0000\u0094\u0095\u0005\u0018\u0000\u0000\u0095\u0096\u0003,\u0016\u0000"+
		"\u0096\u00aa\u0001\u0000\u0000\u0000\u0097\u0098\u0003(\u0014\u0000\u0098"+
		"\u0099\u0003,\u0016\u0000\u0099\u009a\u0005\u0018\u0000\u0000\u009a\u00aa"+
		"\u0001\u0000\u0000\u0000\u009b\u009e\u0005\u0018\u0000\u0000\u009c\u009f"+
		"\u0003(\u0014\u0000\u009d\u009f\u0003,\u0016\u0000\u009e\u009c\u0001\u0000"+
		"\u0000\u0000\u009e\u009d\u0001\u0000\u0000\u0000\u009e\u009f\u0001\u0000"+
		"\u0000\u0000\u009f\u00aa\u0001\u0000\u0000\u0000\u00a0\u00a3\u0003(\u0014"+
		"\u0000\u00a1\u00a4\u0005\u0018\u0000\u0000\u00a2\u00a4\u0003,\u0016\u0000"+
		"\u00a3\u00a1\u0001\u0000\u0000\u0000\u00a3\u00a2\u0001\u0000\u0000\u0000"+
		"\u00a3\u00a4\u0001\u0000\u0000\u0000\u00a4\u00aa\u0001\u0000\u0000\u0000"+
		"\u00a5\u00a7\u0003,\u0016\u0000\u00a6\u00a8\u0005\u0018\u0000\u0000\u00a7"+
		"\u00a6\u0001\u0000\u0000\u0000\u00a7\u00a8\u0001\u0000\u0000\u0000\u00a8"+
		"\u00aa\u0001\u0000\u0000\u0000\u00a9\u008f\u0001\u0000\u0000\u0000\u00a9"+
		"\u0093\u0001\u0000\u0000\u0000\u00a9\u0097\u0001\u0000\u0000\u0000\u00a9"+
		"\u009b\u0001\u0000\u0000\u0000\u00a9\u00a0\u0001\u0000\u0000\u0000\u00a9"+
		"\u00a5\u0001\u0000\u0000\u0000\u00a9\u00aa\u0001\u0000\u0000\u0000\u00aa"+
		"\u0007\u0001\u0000\u0000\u0000\u00ab\u00ad\u0003\f\u0006\u0000\u00ac\u00ae"+
		"\u0003(\u0014\u0000\u00ad\u00ac\u0001\u0000\u0000\u0000\u00ad\u00ae\u0001"+
		"\u0000\u0000\u0000\u00ae\u00b4\u0001\u0000\u0000\u0000\u00af\u00b1\u0003"+
		"\n\u0005\u0000\u00b0\u00af\u0001\u0000\u0000\u0000\u00b1\u00b2\u0001\u0000"+
		"\u0000\u0000\u00b2\u00b0\u0001\u0000\u0000\u0000\u00b2\u00b3\u0001\u0000"+
		"\u0000\u0000\u00b3\u00b5\u0001\u0000\u0000\u0000\u00b4\u00b0\u0001\u0000"+
		"\u0000\u0000\u00b4\u00b5\u0001\u0000\u0000\u0000\u00b5\t\u0001\u0000\u0000"+
		"\u0000\u00b6\u00b8\u0005\u0099\u0000\u0000\u00b7\u00b9\u0005\u0098\u0000"+
		"\u0000\u00b8\u00b7\u0001\u0000\u0000\u0000\u00b8\u00b9\u0001\u0000\u0000"+
		"\u0000\u00b9\u00ba\u0001\u0000\u0000\u0000\u00ba\u00bc\u0003\f\u0006\u0000"+
		"\u00bb\u00bd\u0003(\u0014\u0000\u00bc\u00bb\u0001\u0000\u0000\u0000\u00bc"+
		"\u00bd\u0001\u0000\u0000\u0000\u00bd\u000b\u0001\u0000\u0000\u0000\u00be"+
		"\u00c0\u00052\u0000\u0000\u00bf\u00c1\u0003\u000e\u0007\u0000\u00c0\u00bf"+
		"\u0001\u0000\u0000\u0000\u00c0\u00c1\u0001\u0000\u0000\u0000\u00c1\u00c2"+
		"\u0001\u0000\u0000\u0000\u00c2\u00c5\u0003\u0012\t\u0000\u00c3\u00c4\u0005"+
		"\'\u0000\u0000\u00c4\u00c6\u0003t:\u0000\u00c5\u00c3\u0001\u0000\u0000"+
		"\u0000\u00c5\u00c6\u0001\u0000\u0000\u0000\u00c6\u00c9\u0001\u0000\u0000"+
		"\u0000\u00c7\u00c8\u0005$\u0000\u0000\u00c8\u00ca\u0003\\.\u0000\u00c9"+
		"\u00c7\u0001\u0000\u0000\u0000\u00c9\u00ca\u0001\u0000\u0000\u0000\u00ca"+
		"\u00cd\u0001\u0000\u0000\u0000\u00cb\u00cc\u00059\u0000\u0000\u00cc\u00ce"+
		"\u0003J%\u0000\u00cd\u00cb\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000"+
		"\u0000\u0000\u00ce\u00d2\u0001\u0000\u0000\u0000\u00cf\u00d0\u0005\u008b"+
		"\u0000\u0000\u00d0\u00d1\u0007\u0000\u0000\u0000\u00d1\u00d3\u0003$\u0012"+
		"\u0000\u00d2\u00cf\u0001\u0000\u0000\u0000\u00d2\u00d3\u0001\u0000\u0000"+
		"\u0000\u00d3\u00d6\u0001\u0000\u0000\u0000\u00d4\u00d5\u0005%\u0000\u0000"+
		"\u00d5\u00d7\u0003J%\u0000\u00d6\u00d4\u0001\u0000\u0000\u0000\u00d6\u00d7"+
		"\u0001\u0000\u0000\u0000\u00d7\u00dd\u0001\u0000\u0000\u0000\u00d8\u00d9"+
		"\u0005\u0096\u0000\u0000\u00d9\u00db\u0005\u0097\u0000\u0000\u00da\u00dc"+
		"\u0003x<\u0000\u00db\u00da\u0001\u0000\u0000\u0000\u00db\u00dc\u0001\u0000"+
		"\u0000\u0000\u00dc\u00de\u0001\u0000\u0000\u0000\u00dd\u00d8\u0001\u0000"+
		"\u0000\u0000\u00dd\u00de\u0001\u0000\u0000\u0000\u00de\u00e9\u0001\u0000"+
		"\u0000\u0000\u00df\u00e0\u0005\u008a\u0000\u0000\u00e0\u00e1\u0007\u0000"+
		"\u0000\u0000\u00e1\u00e6\u0003&\u0013\u0000\u00e2\u00e3\u0005\u0007\u0000"+
		"\u0000\u00e3\u00e5\u0003&\u0013\u0000\u00e4\u00e2\u0001\u0000\u0000\u0000"+
		"\u00e5\u00e8\u0001\u0000\u0000\u0000\u00e6\u00e4\u0001\u0000\u0000\u0000"+
		"\u00e6\u00e7\u0001\u0000\u0000\u0000\u00e7\u00ea\u0001\u0000\u0000\u0000"+
		"\u00e8\u00e6\u0001\u0000\u0000\u0000\u00e9\u00df\u0001\u0000\u0000\u0000"+
		"\u00e9\u00ea\u0001\u0000\u0000\u0000\u00ea\r\u0001\u0000\u0000\u0000\u00eb"+
		"\u00ef\u0003\u0010\b\u0000\u00ec\u00ef\u0005\u001e\u0000\u0000\u00ed\u00ef"+
		"\u0005\u0014\u0000\u0000\u00ee\u00eb\u0001\u0000\u0000\u0000\u00ee\u00ec"+
		"\u0001\u0000\u0000\u0000\u00ee\u00ed\u0001\u0000\u0000\u0000\u00ef\u0115"+
		"\u0001\u0000\u0000\u0000\u00f0\u00f1\u0005\u0014\u0000\u0000\u00f1\u00f2"+
		"\u0005\u001e\u0000\u0000\u00f2\u0115\u0003\u0010\b\u0000\u00f3\u00f4\u0005"+
		"\u0014\u0000\u0000\u00f4\u00f5\u0003\u0010\b\u0000\u00f5\u00f6\u0005\u001e"+
		"\u0000\u0000\u00f6\u0115\u0001\u0000\u0000\u0000\u00f7\u00f8\u0003\u0010"+
		"\b\u0000\u00f8\u00f9\u0005\u0014\u0000\u0000\u00f9\u00fa\u0005\u001e\u0000"+
		"\u0000\u00fa\u0115\u0001\u0000\u0000\u0000\u00fb\u00fc\u0003\u0010\b\u0000"+
		"\u00fc\u00fd\u0005\u001e\u0000\u0000\u00fd\u00fe\u0005\u0014\u0000\u0000"+
		"\u00fe\u0115\u0001\u0000\u0000\u0000\u00ff\u0100\u0005\u001e\u0000\u0000"+
		"\u0100\u0101\u0005\u0014\u0000\u0000\u0101\u0115\u0003\u0010\b\u0000\u0102"+
		"\u0103\u0005\u001e\u0000\u0000\u0103\u0104\u0003\u0010\b\u0000\u0104\u0105"+
		"\u0005\u0014\u0000\u0000\u0105\u0115\u0001\u0000\u0000\u0000\u0106\u0107"+
		"\u0005\u0014\u0000\u0000\u0107\u0115\u0005\u001e\u0000\u0000\u0108\u0109"+
		"\u0005\u0014\u0000\u0000\u0109\u0115\u0003\u0010\b\u0000\u010a\u010b\u0005"+
		"\u001e\u0000\u0000\u010b\u0115\u0005\u0014\u0000\u0000\u010c\u010d\u0005"+
		"\u001e\u0000\u0000\u010d\u0115\u0003\u0010\b\u0000\u010e\u010f\u0003\u0010"+
		"\b\u0000\u010f\u0110\u0005\u0014\u0000\u0000\u0110\u0115\u0001\u0000\u0000"+
		"\u0000\u0111\u0112\u0003\u0010\b\u0000\u0112\u0113\u0005\u001e\u0000\u0000"+
		"\u0113\u0115\u0001\u0000\u0000\u0000\u0114\u00ee\u0001\u0000\u0000\u0000"+
		"\u0114\u00f0\u0001\u0000\u0000\u0000\u0114\u00f3\u0001\u0000\u0000\u0000"+
		"\u0114\u00f7\u0001\u0000\u0000\u0000\u0114\u00fb\u0001\u0000\u0000\u0000"+
		"\u0114\u00ff\u0001\u0000\u0000\u0000\u0114\u0102\u0001\u0000\u0000\u0000"+
		"\u0114\u0106\u0001\u0000\u0000\u0000\u0114\u0108\u0001\u0000\u0000\u0000"+
		"\u0114\u010a\u0001\u0000\u0000\u0000\u0114\u010c\u0001\u0000\u0000\u0000"+
		"\u0114\u010e\u0001\u0000\u0000\u0000\u0114\u0111\u0001\u0000\u0000\u0000"+
		"\u0115\u000f\u0001\u0000\u0000\u0000\u0116\u0117\u00054\u0000\u0000\u0117"+
		"\u0118\u0005\u009c\u0000\u0000\u0118\u0011\u0001\u0000\u0000\u0000\u0119"+
		"\u011e\u0003\u0014\n\u0000\u011a\u011b\u0005\u0007\u0000\u0000\u011b\u011d"+
		"\u0003\u0014\n\u0000\u011c\u011a\u0001\u0000\u0000\u0000\u011d\u0120\u0001"+
		"\u0000\u0000\u0000\u011e\u011c\u0001\u0000\u0000\u0000\u011e\u011f\u0001"+
		"\u0000\u0000\u0000\u011f\u0013\u0001\u0000\u0000\u0000\u0120\u011e\u0001"+
		"\u0000\u0000\u0000\u0121\u0127\u0003\u0016\u000b\u0000\u0122\u0127\u0003"+
		"\u001a\r\u0000\u0123\u0127\u0003\u001c\u000e\u0000\u0124\u0127\u0003 "+
		"\u0010\u0000\u0125\u0127\u0003\u0018\f\u0000\u0126\u0121\u0001\u0000\u0000"+
		"\u0000\u0126\u0122\u0001\u0000\u0000\u0000\u0126\u0123\u0001\u0000\u0000"+
		"\u0000\u0126\u0124\u0001\u0000\u0000\u0000\u0126\u0125\u0001\u0000\u0000"+
		"\u0000\u0127\u0129\u0001\u0000\u0000\u0000\u0128\u012a\u0003l6\u0000\u0129"+
		"\u0128\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000\u0000\u0000\u012a"+
		"\u0015\u0001\u0000\u0000\u0000\u012b\u012c\u0003t:\u0000\u012c\u012d\u0005"+
		"\u0003\u0000\u0000\u012d\u012f\u0001\u0000\u0000\u0000\u012e\u012b\u0001"+
		"\u0000\u0000\u0000\u012f\u0132\u0001\u0000\u0000\u0000\u0130\u012e\u0001"+
		"\u0000\u0000\u0000\u0130\u0131\u0001\u0000\u0000\u0000\u0131\u0133\u0001"+
		"\u0000\u0000\u0000\u0132\u0130\u0001\u0000\u0000\u0000\u0133\u0134\u0005"+
		"\u0010\u0000\u0000\u0134\u0017\u0001\u0000\u0000\u0000\u0135\u0136\u0003"+
		"J%\u0000\u0136\u0019\u0001\u0000\u0000\u0000\u0137\u013a\u0005,\u0000"+
		"\u0000\u0138\u013a\u0003\"\u0011\u0000\u0139\u0137\u0001\u0000\u0000\u0000"+
		"\u0139\u0138\u0001\u0000\u0000\u0000\u013a\u001b\u0001\u0000\u0000\u0000"+
		"\u013b\u013c\u0005H\u0000\u0000\u013c\u013d\u0005\u0003\u0000\u0000\u013d"+
		"\u013e\u0005\u0004\u0000\u0000\u013e\u013f\u0003\u001e\u000f\u0000\u013f"+
		"\u0140\u0005\u0005\u0000\u0000\u0140\u001d\u0001\u0000\u0000\u0000\u0141"+
		"\u0146\u0003l6\u0000\u0142\u0143\u0005\u0007\u0000\u0000\u0143\u0145\u0003"+
		"l6\u0000\u0144\u0142\u0001\u0000\u0000\u0000\u0145\u0148\u0001\u0000\u0000"+
		"\u0000\u0146\u0144\u0001\u0000\u0000\u0000\u0146\u0147\u0001\u0000\u0000"+
		"\u0000\u0147\u001f\u0001\u0000\u0000\u0000\u0148\u0146\u0001\u0000\u0000"+
		"\u0000\u0149\u014a\u00032\u0019\u0000\u014a\u014b\u0005\u0003\u0000\u0000"+
		"\u014b\u014c\u0005\u0004\u0000\u0000\u014c\u014d\u0003\u0012\t\u0000\u014d"+
		"\u014e\u0005\u0005\u0000\u0000\u014e!\u0001\u0000\u0000\u0000\u014f\u0150"+
		"\u0005\\\u0000\u0000\u0150\u0151\u0005\u0004\u0000\u0000\u0151\u0152\u0005"+
		"\u0005\u0000\u0000\u0152#\u0001\u0000\u0000\u0000\u0153\u0154\u0005\u008e"+
		"\u0000\u0000\u0154\u0155\u0005\u008f\u0000\u0000\u0155\u0156\u0005\u0004"+
		"\u0000\u0000\u0156\u0157\u0005\u0004\u0000\u0000\u0157\u0158\u0003Z-\u0000"+
		"\u0158\u0160\u0005\u0005\u0000\u0000\u0159\u015a\u0005\u0007\u0000\u0000"+
		"\u015a\u015b\u0005\u0004\u0000\u0000\u015b\u015c\u0003Z-\u0000\u015c\u015d"+
		"\u0005\u0005\u0000\u0000\u015d\u015f\u0001\u0000\u0000\u0000\u015e\u0159"+
		"\u0001\u0000\u0000\u0000\u015f\u0162\u0001\u0000\u0000\u0000\u0160\u015e"+
		"\u0001\u0000\u0000\u0000\u0160\u0161\u0001\u0000\u0000\u0000\u0161\u0163"+
		"\u0001\u0000\u0000\u0000\u0162\u0160\u0001\u0000\u0000\u0000\u0163\u0164"+
		"\u0005\u0005\u0000\u0000\u0164\u016e\u0001\u0000\u0000\u0000\u0165\u016a"+
		"\u00034\u001a\u0000\u0166\u0167\u0005\u0007\u0000\u0000\u0167\u0169\u0003"+
		"4\u001a\u0000\u0168\u0166\u0001\u0000\u0000\u0000\u0169\u016c\u0001\u0000"+
		"\u0000\u0000\u016a\u0168\u0001\u0000\u0000\u0000\u016a\u016b\u0001\u0000"+
		"\u0000\u0000\u016b\u016e\u0001\u0000\u0000\u0000\u016c\u016a\u0001\u0000"+
		"\u0000\u0000\u016d\u0153\u0001\u0000\u0000\u0000\u016d\u0165\u0001\u0000"+
		"\u0000\u0000\u016e%\u0001\u0000\u0000\u0000\u016f\u0172\u0003v;\u0000"+
		"\u0170\u0172\u00032\u0019\u0000\u0171\u016f\u0001\u0000\u0000\u0000\u0171"+
		"\u0170\u0001\u0000\u0000\u0000\u0172\'\u0001\u0000\u0000\u0000\u0173\u0174"+
		"\u0005\u008c\u0000\u0000\u0174\u0175\u0007\u0000\u0000\u0000\u0175\u0178"+
		"\u0003*\u0015\u0000\u0176\u0177\u0005\u0007\u0000\u0000\u0177\u0179\u0003"+
		"*\u0015\u0000\u0178\u0176\u0001\u0000\u0000\u0000\u0178\u0179\u0001\u0000"+
		"\u0000\u0000\u0179)\u0001\u0000\u0000\u0000\u017a\u0180\u00034\u001a\u0000"+
		"\u017b\u0181\u0007\u0001\u0000\u0000\u017c\u017e\u0005&\u0000\u0000\u017d"+
		"\u017f\u0005\u001d\u0000\u0000\u017e\u017d\u0001\u0000\u0000\u0000\u017e"+
		"\u017f\u0001\u0000\u0000\u0000\u017f\u0181\u0001\u0000\u0000\u0000\u0180"+
		"\u017b\u0001\u0000\u0000\u0000\u0180\u017c\u0001\u0000\u0000\u0000\u0180"+
		"\u0181\u0001\u0000\u0000\u0000\u0181+\u0001\u0000\u0000\u0000\u0182\u0184"+
		"\u00055\u0000\u0000\u0183\u0185\u0003\u0012\t\u0000\u0184\u0183\u0001"+
		"\u0000\u0000\u0000\u0184\u0185\u0001\u0000\u0000\u0000\u0185\u0186\u0001"+
		"\u0000\u0000\u0000\u0186\u0187\u0007\u0000\u0000\u0000\u0187\u018c\u0003"+
		".\u0017\u0000\u0188\u0189\u0005\u0007\u0000\u0000\u0189\u018b\u0003.\u0017"+
		"\u0000\u018a\u0188\u0001\u0000\u0000\u0000\u018b\u018e\u0001\u0000\u0000"+
		"\u0000\u018c\u018a\u0001\u0000\u0000\u0000\u018c\u018d\u0001\u0000\u0000"+
		"\u0000\u018d-\u0001\u0000\u0000\u0000\u018e\u018c\u0001\u0000\u0000\u0000"+
		"\u018f\u019c\u00050\u0000\u0000\u0190\u0196\u00034\u001a\u0000\u0191\u0193"+
		"\u0005X\u0000\u0000\u0192\u0191\u0001\u0000\u0000\u0000\u0192\u0193\u0001"+
		"\u0000\u0000\u0000\u0193\u0194\u0001\u0000\u0000\u0000\u0194\u0197\u0005"+
		"&\u0000\u0000\u0195\u0197\u00030\u0018\u0000\u0196\u0192\u0001\u0000\u0000"+
		"\u0000\u0196\u0195\u0001\u0000\u0000\u0000\u0196\u0197\u0001\u0000\u0000"+
		"\u0000\u0197\u0199\u0001\u0000\u0000\u0000\u0198\u019a\u0003l6\u0000\u0199"+
		"\u0198\u0001\u0000\u0000\u0000\u0199\u019a\u0001\u0000\u0000\u0000\u019a"+
		"\u019c\u0001\u0000\u0000\u0000\u019b\u018f\u0001\u0000\u0000\u0000\u019b"+
		"\u0190\u0001\u0000\u0000\u0000\u019c/\u0001\u0000\u0000\u0000\u019d\u019e"+
		"\u0005Y\u0000\u0000\u019e\u019f\u0005\u0004\u0000\u0000\u019f\u01a2\u0007"+
		"\u0002\u0000\u0000\u01a0\u01a1\u0005\u0007\u0000\u0000\u01a1\u01a3\u0003"+
		"4\u001a\u0000\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001\u0000"+
		"\u0000\u0000\u01a3\u01a6\u0001\u0000\u0000\u0000\u01a4\u01a5\u0005\u0007"+
		"\u0000\u0000\u01a5\u01a7\u00034\u001a\u0000\u01a6\u01a4\u0001\u0000\u0000"+
		"\u0000\u01a6\u01a7\u0001\u0000\u0000\u0000\u01a7\u01a8\u0001\u0000\u0000"+
		"\u0000\u01a8\u01a9\u0005\u0005\u0000\u0000\u01a91\u0001\u0000\u0000\u0000"+
		"\u01aa\u01ad\u0003t:\u0000\u01ab\u01ac\u0005\u0003\u0000\u0000\u01ac\u01ae"+
		"\u0003t:\u0000\u01ad\u01ab\u0001\u0000\u0000\u0000\u01ae\u01af\u0001\u0000"+
		"\u0000\u0000\u01af\u01ad\u0001\u0000\u0000\u0000\u01af\u01b0\u0001\u0000"+
		"\u0000\u0000\u01b0\u01ba\u0001\u0000\u0000\u0000\u01b1\u01ba\u0003t:\u0000"+
		"\u01b2\u01b5\u0003x<\u0000\u01b3\u01b4\u0005\u0003\u0000\u0000\u01b4\u01b6"+
		"\u0003t:\u0000\u01b5\u01b3\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000"+
		"\u0000\u0000\u01b7\u01b5\u0001\u0000\u0000\u0000\u01b7\u01b8\u0001\u0000"+
		"\u0000\u0000\u01b8\u01ba\u0001\u0000\u0000\u0000\u01b9\u01aa\u0001\u0000"+
		"\u0000\u0000\u01b9\u01b1\u0001\u0000\u0000\u0000\u01b9\u01b2\u0001\u0000"+
		"\u0000\u0000\u01ba3\u0001\u0000\u0000\u0000\u01bb\u01bc\u0006\u001a\uffff"+
		"\uffff\u0000\u01bc\u01c3\u00036\u001b\u0000\u01bd\u01c3\u0003@ \u0000"+
		"\u01be\u01c3\u00038\u001c\u0000\u01bf\u01c3\u00032\u0019\u0000\u01c0\u01c3"+
		"\u0003<\u001e\u0000\u01c1\u01c3\u0003>\u001f\u0000\u01c2\u01bb\u0001\u0000"+
		"\u0000\u0000\u01c2\u01bd\u0001\u0000\u0000\u0000\u01c2\u01be\u0001\u0000"+
		"\u0000\u0000\u01c2\u01bf\u0001\u0000\u0000\u0000\u01c2\u01c0\u0001\u0000"+
		"\u0000\u0000\u01c2\u01c1\u0001\u0000\u0000\u0000\u01c3\u01c9\u0001\u0000"+
		"\u0000\u0000\u01c4\u01c5\n\u0001\u0000\u0000\u01c5\u01c6\u0007\u0003\u0000"+
		"\u0000\u01c6\u01c8\u00034\u001a\u0002\u01c7\u01c4\u0001\u0000\u0000\u0000"+
		"\u01c8\u01cb\u0001\u0000\u0000\u0000\u01c9\u01c7\u0001\u0000\u0000\u0000"+
		"\u01c9\u01ca\u0001\u0000\u0000\u0000\u01ca5\u0001\u0000\u0000\u0000\u01cb"+
		"\u01c9\u0001\u0000\u0000\u0000\u01cc\u01f0\u0005,\u0000\u0000\u01cd\u01f0"+
		"\u00057\u0000\u0000\u01ce\u01f0\u0003p8\u0000\u01cf\u01f0\u0005\u009c"+
		"\u0000\u0000\u01d0\u01f0\u0005\u009d\u0000\u0000\u01d1\u01f0\u0007\u0004"+
		"\u0000\u0000\u01d2\u01d3\u0005E\u0000\u0000\u01d3\u01d4\u0005\u0004\u0000"+
		"\u0000\u01d4\u01d5\u0003n7\u0000\u01d5\u01d6\u0005\u0007\u0000\u0000\u01d6"+
		"\u01d7\u0003n7\u0000\u01d7\u01d8\u0005\u0007\u0000\u0000\u01d8\u01e0\u0003"+
		"n7\u0000\u01d9\u01da\u0005\u0007\u0000\u0000\u01da\u01db\u0003n7\u0000"+
		"\u01db\u01dc\u0005\u0007\u0000\u0000\u01dc\u01dd\u0003n7\u0000\u01dd\u01de"+
		"\u0005\u0007\u0000\u0000\u01de\u01df\u0003n7\u0000\u01df\u01e1\u0001\u0000"+
		"\u0000\u0000\u01e0\u01d9\u0001\u0000\u0000\u0000\u01e0\u01e1\u0001\u0000"+
		"\u0000\u0000\u01e1\u01e2\u0001\u0000\u0000\u0000\u01e2\u01e3\u0005\u0005"+
		"\u0000\u0000\u01e3\u01f0\u0001\u0000\u0000\u0000\u01e4\u01f0\u0003v;\u0000"+
		"\u01e5\u01e6\u0005o\u0000\u0000\u01e6\u01ec\u0005\u0004\u0000\u0000\u01e7"+
		"\u01ed\u0003x<\u0000\u01e8\u01ed\u0005d\u0000\u0000\u01e9\u01ed\u0005"+
		"?\u0000\u0000\u01ea\u01ed\u0005B\u0000\u0000\u01eb\u01ed\u0005V\u0000"+
		"\u0000\u01ec\u01e7\u0001\u0000\u0000\u0000\u01ec\u01e8\u0001\u0000\u0000"+
		"\u0000\u01ec\u01e9\u0001\u0000\u0000\u0000\u01ec\u01ea\u0001\u0000\u0000"+
		"\u0000\u01ec\u01eb\u0001\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000"+
		"\u0000\u01ee\u01f0\u0005\u0005\u0000\u0000\u01ef\u01cc\u0001\u0000\u0000"+
		"\u0000\u01ef\u01cd\u0001\u0000\u0000\u0000\u01ef\u01ce\u0001\u0000\u0000"+
		"\u0000\u01ef\u01cf\u0001\u0000\u0000\u0000\u01ef\u01d0\u0001\u0000\u0000"+
		"\u0000\u01ef\u01d1\u0001\u0000\u0000\u0000\u01ef\u01d2\u0001\u0000\u0000"+
		"\u0000\u01ef\u01e4\u0001\u0000\u0000\u0000\u01ef\u01e5\u0001\u0000\u0000"+
		"\u0000\u01f07\u0001\u0000\u0000\u0000\u01f1\u01f2\u0005\u001b\u0000\u0000"+
		"\u01f2\u01f4\u00034\u001a\u0000\u01f3\u01f5\u0003:\u001d\u0000\u01f4\u01f3"+
		"\u0001\u0000\u0000\u0000\u01f5\u01f6\u0001\u0000\u0000\u0000\u01f6\u01f4"+
		"\u0001\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7\u01fa"+
		"\u0001\u0000\u0000\u0000\u01f8\u01f9\u0005 \u0000\u0000\u01f9\u01fb\u0003"+
		"J%\u0000\u01fa\u01f8\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000"+
		"\u0000\u01fb\u01fc\u0001\u0000\u0000\u0000\u01fc\u01fd\u0005!\u0000\u0000"+
		"\u01fd\u0212\u0001\u0000\u0000\u0000\u01fe\u0200\u0005\u001b\u0000\u0000"+
		"\u01ff\u0201\u0003:\u001d\u0000\u0200\u01ff\u0001\u0000\u0000\u0000\u0201"+
		"\u0202\u0001\u0000\u0000\u0000\u0202\u0200\u0001\u0000\u0000\u0000\u0202"+
		"\u0203\u0001\u0000\u0000\u0000\u0203\u0206\u0001\u0000\u0000\u0000\u0204"+
		"\u0205\u0005 \u0000\u0000\u0205\u0207\u0003J%\u0000\u0206\u0204\u0001"+
		"\u0000\u0000\u0000\u0206\u0207\u0001\u0000\u0000\u0000\u0207\u0208\u0001"+
		"\u0000\u0000\u0000\u0208\u0209\u0005!\u0000\u0000\u0209\u0212\u0001\u0000"+
		"\u0000\u0000\u020a\u020d\u0003:\u001d\u0000\u020b\u020c\u0005 \u0000\u0000"+
		"\u020c\u020e\u0003J%\u0000\u020d\u020b\u0001\u0000\u0000\u0000\u020d\u020e"+
		"\u0001\u0000\u0000\u0000\u020e\u020f\u0001\u0000\u0000\u0000\u020f\u0210"+
		"\u0005!\u0000\u0000\u0210\u0212\u0001\u0000\u0000\u0000\u0211\u01f1\u0001"+
		"\u0000\u0000\u0000\u0211\u01fe\u0001\u0000\u0000\u0000\u0211\u020a\u0001"+
		"\u0000\u0000\u0000\u02129\u0001\u0000\u0000\u0000\u0213\u0214\u00058\u0000"+
		"\u0000\u0214\u0215\u0003J%\u0000\u0215\u0216\u00053\u0000\u0000\u0216"+
		"\u0217\u0003J%\u0000\u0217;\u0001\u0000\u0000\u0000\u0218\u0219\u0005"+
		"\u0004\u0000\u0000\u0219\u021a\u00034\u001a\u0000\u021a\u021b\u0005\u0005"+
		"\u0000\u0000\u021b\u0221\u0001\u0000\u0000\u0000\u021c\u021d\u0005\u0004"+
		"\u0000\u0000\u021d\u021e\u0003\b\u0004\u0000\u021e\u021f\u0005\u0005\u0000"+
		"\u0000\u021f\u0221\u0001\u0000\u0000\u0000\u0220\u0218\u0001\u0000\u0000"+
		"\u0000\u0220\u021c\u0001\u0000\u0000\u0000\u0221=\u0001\u0000\u0000\u0000"+
		"\u0222\u0223\u0003r9\u0000\u0223\u0224\u00034\u001a\u0000\u0224?\u0001"+
		"\u0000\u0000\u0000\u0225\u0238\u0003D\"\u0000\u0226\u0238\u0003B!\u0000"+
		"\u0227\u022c\u0003F#\u0000\u0228\u0229\u0005\u0003\u0000\u0000\u0229\u022b"+
		"\u0003t:\u0000\u022a\u0228\u0001\u0000\u0000\u0000\u022b\u022e\u0001\u0000"+
		"\u0000\u0000\u022c\u022a\u0001\u0000\u0000\u0000\u022c\u022d\u0001\u0000"+
		"\u0000\u0000\u022d\u0238\u0001\u0000\u0000\u0000\u022e\u022c\u0001\u0000"+
		"\u0000\u0000\u022f\u0234\u0003H$\u0000\u0230\u0231\u0005\u0003\u0000\u0000"+
		"\u0231\u0233\u0003t:\u0000\u0232\u0230\u0001\u0000\u0000\u0000\u0233\u0236"+
		"\u0001\u0000\u0000\u0000\u0234\u0232\u0001\u0000\u0000\u0000\u0234\u0235"+
		"\u0001\u0000\u0000\u0000\u0235\u0238\u0001\u0000\u0000\u0000\u0236\u0234"+
		"\u0001\u0000\u0000\u0000\u0237\u0225\u0001\u0000\u0000\u0000\u0237\u0226"+
		"\u0001\u0000\u0000\u0000\u0237\u0227\u0001\u0000\u0000\u0000\u0237\u022f"+
		"\u0001\u0000\u0000\u0000\u0238A\u0001\u0000\u0000\u0000\u0239\u023a\u0005"+
		"h\u0000\u0000\u023a\u023b\u0005\u0004\u0000\u0000\u023b\u023c\u00034\u001a"+
		"\u0000\u023c\u023d\u0005\u0007\u0000\u0000\u023d\u023e\u00034\u001a\u0000"+
		"\u023e\u023f\u0005\u0007\u0000\u0000\u023f\u0240\u00034\u001a\u0000\u0240"+
		"\u0241\u0005\u0005\u0000\u0000\u0241\u0293\u0001\u0000\u0000\u0000\u0242"+
		"\u0243\u0007\u0005\u0000\u0000\u0243\u0244\u0005\u0004\u0000\u0000\u0244"+
		"\u0245\u00034\u001a\u0000\u0245\u0246\u0005\u0005\u0000\u0000\u0246\u0293"+
		"\u0001\u0000\u0000\u0000\u0247\u0248\u0007\u0006\u0000\u0000\u0248\u0249"+
		"\u0005\u0004\u0000\u0000\u0249\u024a\u00034\u001a\u0000\u024a\u024b\u0005"+
		"\u0007\u0000\u0000\u024b\u024c\u0007\u0007\u0000\u0000\u024c\u024d\u0005"+
		"\u0005\u0000\u0000\u024d\u0293\u0001\u0000\u0000\u0000\u024e\u024f\u0005"+
		"C\u0000\u0000\u024f\u0250\u0005\u0004\u0000\u0000\u0250\u0251\u00034\u001a"+
		"\u0000\u0251\u0252\u0005\u0007\u0000\u0000\u0252\u0253\u0007\u0002\u0000"+
		"\u0000\u0253\u0254\u0005\u0007\u0000\u0000\u0254\u0255\u00034\u001a\u0000"+
		"\u0255\u0256\u0005\u0005\u0000\u0000\u0256\u0293\u0001\u0000\u0000\u0000"+
		"\u0257\u0258\u0005D\u0000\u0000\u0258\u0259\u0005\u0004\u0000\u0000\u0259"+
		"\u025a\u00034\u001a\u0000\u025a\u025b\u0005\u0007\u0000\u0000\u025b\u025c"+
		"\u00034\u001a\u0000\u025c\u025d\u0005\u0007\u0000\u0000\u025d\u025e\u0007"+
		"\b\u0000\u0000\u025e\u025f\u0005\u0005\u0000\u0000\u025f\u0293\u0001\u0000"+
		"\u0000\u0000\u0260\u0261\u0007\t\u0000\u0000\u0261\u0262\u0005\u0004\u0000"+
		"\u0000\u0262\u0263\u00034\u001a\u0000\u0263\u0264\u0005\u0005\u0000\u0000"+
		"\u0264\u0293\u0001\u0000\u0000\u0000\u0265\u0266\u0005)\u0000\u0000\u0266"+
		"\u0267\u0005\u0004\u0000\u0000\u0267\u0268\u0003J%\u0000\u0268\u0269\u0005"+
		"\u0007\u0000\u0000\u0269\u026a\u0003J%\u0000\u026a\u026b\u0005\u0005\u0000"+
		"\u0000\u026b\u0293\u0001\u0000\u0000\u0000\u026c\u026d\u0007\n\u0000\u0000"+
		"\u026d\u026e\u0005\u0004\u0000\u0000\u026e\u026f\u00034\u001a\u0000\u026f"+
		"\u0270\u0005\u0005\u0000\u0000\u0270\u0293\u0001\u0000\u0000\u0000\u0271"+
		"\u0272\u0007\u000b\u0000\u0000\u0272\u0273\u0005\u0004\u0000\u0000\u0273"+
		"\u0274\u00034\u001a\u0000\u0274\u0275\u0005\u0005\u0000\u0000\u0275\u0293"+
		"\u0001\u0000\u0000\u0000\u0276\u0277\u0005_\u0000\u0000\u0277\u0278\u0005"+
		"\u0004\u0000\u0000\u0278\u0279\u00034\u001a\u0000\u0279\u027a\u0005\u0007"+
		"\u0000\u0000\u027a\u027b\u00034\u001a\u0000\u027b\u027c\u0005\u0005\u0000"+
		"\u0000\u027c\u0293\u0001\u0000\u0000\u0000\u027d\u027e\u0007\f\u0000\u0000"+
		"\u027e\u027f\u0005\u0004\u0000\u0000\u027f\u0280\u00034\u001a\u0000\u0280"+
		"\u0281\u0005\u0005\u0000\u0000\u0281\u0293\u0001\u0000\u0000\u0000\u0282"+
		"\u0283\u0005f\u0000\u0000\u0283\u0284\u0005\u0004\u0000\u0000\u0284\u0285"+
		"\u00034\u001a\u0000\u0285\u0286\u0005\u0007\u0000\u0000\u0286\u0287\u0003"+
		"4\u001a\u0000\u0287\u0288\u0005\u0005\u0000\u0000\u0288\u0293\u0001\u0000"+
		"\u0000\u0000\u0289\u028a\u0005g\u0000\u0000\u028a\u028b\u0005\u0004\u0000"+
		"\u0000\u028b\u028c\u00034\u001a\u0000\u028c\u028d\u0005\u0007\u0000\u0000"+
		"\u028d\u028e\u00034\u001a\u0000\u028e\u028f\u0005\u0007\u0000\u0000\u028f"+
		"\u0290\u00034\u001a\u0000\u0290\u0291\u0005\u0005\u0000\u0000\u0291\u0293"+
		"\u0001\u0000\u0000\u0000\u0292\u0239\u0001\u0000\u0000\u0000\u0292\u0242"+
		"\u0001\u0000\u0000\u0000\u0292\u0247\u0001\u0000\u0000\u0000\u0292\u024e"+
		"\u0001\u0000\u0000\u0000\u0292\u0257\u0001\u0000\u0000\u0000\u0292\u0260"+
		"\u0001\u0000\u0000\u0000\u0292\u0265\u0001\u0000\u0000\u0000\u0292\u026c"+
		"\u0001\u0000\u0000\u0000\u0292\u0271\u0001\u0000\u0000\u0000\u0292\u0276"+
		"\u0001\u0000\u0000\u0000\u0292\u027d\u0001\u0000\u0000\u0000\u0292\u0282"+
		"\u0001\u0000\u0000\u0000\u0292\u0289\u0001\u0000\u0000\u0000\u0293C\u0001"+
		"\u0000\u0000\u0000\u0294\u0295\u0007\r\u0000\u0000\u0295\u0296\u0005\u0004"+
		"\u0000\u0000\u0296\u0297\u0003J%\u0000\u0297\u0298\u0005\u0005\u0000\u0000"+
		"\u0298\u02a4\u0001\u0000\u0000\u0000\u0299\u029a\u0005A\u0000\u0000\u029a"+
		"\u02a0\u0005\u0004\u0000\u0000\u029b\u029d\u0005\u001e\u0000\u0000\u029c"+
		"\u029b\u0001\u0000\u0000\u0000\u029c\u029d\u0001\u0000\u0000\u0000\u029d"+
		"\u029e\u0001\u0000\u0000\u0000\u029e\u02a1\u0003J%\u0000\u029f\u02a1\u0005"+
		"\u0010\u0000\u0000\u02a0\u029c\u0001\u0000\u0000\u0000\u02a0\u029f\u0001"+
		"\u0000\u0000\u0000\u02a1\u02a2\u0001\u0000\u0000\u0000\u02a2\u02a4\u0005"+
		"\u0005\u0000\u0000\u02a3\u0294\u0001\u0000\u0000\u0000\u02a3\u0299\u0001"+
		"\u0000\u0000\u0000\u02a4E\u0001\u0000\u0000\u0000\u02a5\u02a6\u0005q\u0000"+
		"\u0000\u02a6\u02c2\u0005\u0004\u0000\u0000\u02a7\u02a8\u0007\u000e\u0000"+
		"\u0000\u02a8\u02a9\u0005\u0003\u0000\u0000\u02a9\u02aa\u0003t:\u0000\u02aa"+
		"\u02ab\u0005\u0003\u0000\u0000\u02ab\u02ac\u0005I\u0000\u0000\u02ac\u02c3"+
		"\u0001\u0000\u0000\u0000\u02ad\u02ae\u0007\u000f\u0000\u0000\u02ae\u02af"+
		"\u0005\u0003\u0000\u0000\u02af\u02b0\u0003t:\u0000\u02b0\u02b1\u0005\u0003"+
		"\u0000\u0000\u02b1\u02b2\u0003t:\u0000\u02b2\u02c3\u0001\u0000\u0000\u0000"+
		"\u02b3\u02b4\u0005y\u0000\u0000\u02b4\u02b5\u0005\u0003\u0000\u0000\u02b5"+
		"\u02b6\u0003t:\u0000\u02b6\u02b7\u0005\u0003\u0000\u0000\u02b7\u02b8\u0005"+
		"\u0089\u0000\u0000\u02b8\u02b9\u0005\u0003\u0000\u0000\u02b9\u02ba\u0003"+
		"t:\u0000\u02ba\u02c3\u0001\u0000\u0000\u0000\u02bb\u02bc\u0003t:\u0000"+
		"\u02bc\u02bd\u0005\u0003\u0000\u0000\u02bd\u02be\u0003t:\u0000\u02be\u02c3"+
		"\u0001\u0000\u0000\u0000\u02bf\u02c0\u0003x<\u0000\u02c0\u02c1\u0005\u0003"+
		"\u0000\u0000\u02c1\u02c3\u0001\u0000\u0000\u0000\u02c2\u02a7\u0001\u0000"+
		"\u0000\u0000\u02c2\u02ad\u0001\u0000\u0000\u0000\u02c2\u02b3\u0001\u0000"+
		"\u0000\u0000\u02c2\u02bb\u0001\u0000\u0000\u0000\u02c2\u02bf\u0001\u0000"+
		"\u0000\u0000\u02c3\u02c4\u0001\u0000\u0000\u0000\u02c4\u02c5\u0005\u0005"+
		"\u0000\u0000\u02c5G\u0001\u0000\u0000\u0000\u02c6\u02c7\u0005\u001c\u0000"+
		"\u0000\u02c7\u02c8\u0005\u0004\u0000\u0000\u02c8\u02c9\u00034\u001a\u0000"+
		"\u02c9\u02dd\u0005\u0016\u0000\u0000\u02ca\u02de\u0005?\u0000\u0000\u02cb"+
		"\u02d3\u0005V\u0000\u0000\u02cc\u02cd\u0005\u0004\u0000\u0000\u02cd\u02d0"+
		"\u0005\u009c\u0000\u0000\u02ce\u02cf\u0005\u0007\u0000\u0000\u02cf\u02d1"+
		"\u0005\u009c\u0000\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000\u02d0\u02d1"+
		"\u0001\u0000\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000\u02d2\u02d4"+
		"\u0005\u0005\u0000\u0000\u02d3\u02cc\u0001\u0000\u0000\u0000\u02d3\u02d4"+
		"\u0001\u0000\u0000\u0000\u02d4\u02de\u0001\u0000\u0000\u0000\u02d5\u02d9"+
		"\u0005d\u0000\u0000\u02d6\u02d7\u0005\u0004\u0000\u0000\u02d7\u02d8\u0005"+
		"\u009c\u0000\u0000\u02d8\u02da\u0005\u0005\u0000\u0000\u02d9\u02d6\u0001"+
		"\u0000\u0000\u0000\u02d9\u02da\u0001\u0000\u0000\u0000\u02da\u02de\u0001"+
		"\u0000\u0000\u0000\u02db\u02de\u0005B\u0000\u0000\u02dc\u02de\u0003x<"+
		"\u0000\u02dd\u02ca\u0001\u0000\u0000\u0000\u02dd\u02cb\u0001\u0000\u0000"+
		"\u0000\u02dd\u02d5\u0001\u0000\u0000\u0000\u02dd\u02db\u0001\u0000\u0000"+
		"\u0000\u02dd\u02dc\u0001\u0000\u0000\u0000\u02de\u02df\u0001\u0000\u0000"+
		"\u0000\u02df\u02e0\u0005\u0005\u0000\u0000\u02e0I\u0001\u0000\u0000\u0000"+
		"\u02e1\u02e6\u0003L&\u0000\u02e2\u02e3\u0007\u0010\u0000\u0000\u02e3\u02e5"+
		"\u0003L&\u0000\u02e4\u02e2\u0001\u0000\u0000\u0000\u02e5\u02e8\u0001\u0000"+
		"\u0000\u0000\u02e6\u02e4\u0001\u0000\u0000\u0000\u02e6\u02e7\u0001\u0000"+
		"\u0000\u0000\u02e7K\u0001\u0000\u0000\u0000\u02e8\u02e6\u0001\u0000\u0000"+
		"\u0000\u02e9\u02eb\u0005+\u0000\u0000\u02ea\u02e9\u0001\u0000\u0000\u0000"+
		"\u02eb\u02ee\u0001\u0000\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000"+
		"\u02ec\u02ed\u0001\u0000\u0000\u0000\u02ed\u02fa\u0001\u0000\u0000\u0000"+
		"\u02ee\u02ec\u0001\u0000\u0000\u0000\u02ef\u02fb\u00034\u001a\u0000\u02f0"+
		"\u02fb\u0003N\'\u0000\u02f1\u02fb\u0003P(\u0000\u02f2\u02fb\u0003R)\u0000"+
		"\u02f3\u02fb\u0003T*\u0000\u02f4\u02fb\u0003V+\u0000\u02f5\u02fb\u0003"+
		"X,\u0000\u02f6\u02f7\u0005\u0004\u0000\u0000\u02f7\u02f8\u0003J%\u0000"+
		"\u02f8\u02f9\u0005\u0005\u0000\u0000\u02f9\u02fb\u0001\u0000\u0000\u0000"+
		"\u02fa\u02ef\u0001\u0000\u0000\u0000\u02fa\u02f0\u0001\u0000\u0000\u0000"+
		"\u02fa\u02f1\u0001\u0000\u0000\u0000\u02fa\u02f2\u0001\u0000\u0000\u0000"+
		"\u02fa\u02f3\u0001\u0000\u0000\u0000\u02fa\u02f4\u0001\u0000\u0000\u0000"+
		"\u02fa\u02f5\u0001\u0000\u0000\u0000\u02fa\u02f6\u0001\u0000\u0000\u0000"+
		"\u02fbM\u0001\u0000\u0000\u0000\u02fc\u0300\u00034\u001a\u0000\u02fd\u02ff"+
		"\u0005+\u0000\u0000\u02fe\u02fd\u0001\u0000\u0000\u0000\u02ff\u0302\u0001"+
		"\u0000\u0000\u0000\u0300\u02fe\u0001\u0000\u0000\u0000\u0300\u0301\u0001"+
		"\u0000\u0000\u0000\u0301\u0303\u0001\u0000\u0000\u0000\u0302\u0300\u0001"+
		"\u0000\u0000\u0000\u0303\u0304\u0005*\u0000\u0000\u0304\u0307\u00034\u001a"+
		"\u0000\u0305\u0306\u0005\"\u0000\u0000\u0306\u0308\u0003p8\u0000\u0307"+
		"\u0305\u0001\u0000\u0000\u0000\u0307\u0308\u0001\u0000\u0000\u0000\u0308"+
		"O\u0001\u0000\u0000\u0000\u0309\u030a\u00034\u001a\u0000\u030a\u030c\u0005"+
		"(\u0000\u0000\u030b\u030d\u0005+\u0000\u0000\u030c\u030b\u0001\u0000\u0000"+
		"\u0000\u030c\u030d\u0001\u0000\u0000\u0000\u030d\u030e\u0001\u0000\u0000"+
		"\u0000\u030e\u030f\u0005,\u0000\u0000\u030fQ\u0001\u0000\u0000\u0000\u0310"+
		"\u0311\u00034\u001a\u0000\u0311\u0312\u0007\u0011\u0000\u0000\u0312\u0313"+
		"\u00034\u001a\u0000\u0313S\u0001\u0000\u0000\u0000\u0314\u0315\u00034"+
		"\u001a\u0000\u0315\u0316\u0005\u0019\u0000\u0000\u0316\u0317\u00034\u001a"+
		"\u0000\u0317\u0318\u0005\u0015\u0000\u0000\u0318\u0319\u00034\u001a\u0000"+
		"\u0319U\u0001\u0000\u0000\u0000\u031a\u0320\u00034\u001a\u0000\u031b\u031c"+
		"\u0005\u0004\u0000\u0000\u031c\u031d\u0003Z-\u0000\u031d\u031e\u0005\u0005"+
		"\u0000\u0000\u031e\u0320\u0001\u0000\u0000\u0000\u031f\u031a\u0001\u0000"+
		"\u0000\u0000\u031f\u031b\u0001\u0000\u0000\u0000\u0320\u0324\u0001\u0000"+
		"\u0000\u0000\u0321\u0323\u0005+\u0000\u0000\u0322\u0321\u0001\u0000\u0000"+
		"\u0000\u0323\u0326\u0001\u0000\u0000\u0000\u0324\u0322\u0001\u0000\u0000"+
		"\u0000\u0324\u0325\u0001\u0000\u0000\u0000\u0325\u0327\u0001\u0000\u0000"+
		"\u0000\u0326\u0324\u0001\u0000\u0000\u0000\u0327\u0329\u0005\u009b\u0000"+
		"\u0000\u0328\u032a\u0005\u009a\u0000\u0000\u0329\u0328\u0001\u0000\u0000"+
		"\u0000\u0329\u032a\u0001\u0000\u0000\u0000\u032a\u032b\u0001\u0000\u0000"+
		"\u0000\u032b\u032e\u0005\u0004\u0000\u0000\u032c\u032f\u0003\b\u0004\u0000"+
		"\u032d\u032f\u0003Z-\u0000\u032e\u032c\u0001\u0000\u0000\u0000\u032e\u032d"+
		"\u0001\u0000\u0000\u0000\u032f\u0330\u0001\u0000\u0000\u0000\u0330\u0331"+
		"\u0005\u0005\u0000\u0000\u0331W\u0001\u0000\u0000\u0000\u0332\u0333\u0003"+
		"4\u001a\u0000\u0333\u0334\u0005Z\u0000\u0000\u0334\u0335\u0003x<\u0000"+
		"\u0335Y\u0001\u0000\u0000\u0000\u0336\u033b\u0003J%\u0000\u0337\u0338"+
		"\u0005\u0007\u0000\u0000\u0338\u033a\u0003J%\u0000\u0339\u0337\u0001\u0000"+
		"\u0000\u0000\u033a\u033d\u0001\u0000\u0000\u0000\u033b\u0339\u0001\u0000"+
		"\u0000\u0000\u033b\u033c\u0001\u0000\u0000\u0000\u033c[\u0001\u0000\u0000"+
		"\u0000\u033d\u033b\u0001\u0000\u0000\u0000\u033e\u0343\u0003^/\u0000\u033f"+
		"\u0340\u0005\u0007\u0000\u0000\u0340\u0342\u0003^/\u0000\u0341\u033f\u0001"+
		"\u0000\u0000\u0000\u0342\u0345\u0001\u0000\u0000\u0000\u0343\u0341\u0001"+
		"\u0000\u0000\u0000\u0343\u0344\u0001\u0000\u0000\u0000\u0344]\u0001\u0000"+
		"\u0000\u0000\u0345\u0343\u0001\u0000\u0000\u0000\u0346\u0347\u0005\u0004"+
		"\u0000\u0000\u0347\u0348\u0003^/\u0000\u0348\u0349\u0005\u0005\u0000\u0000"+
		"\u0349\u0367\u0001\u0000\u0000\u0000\u034a\u034f\u0003b1\u0000\u034b\u034f"+
		"\u0003`0\u0000\u034c\u034f\u0003f3\u0000\u034d\u034f\u0003h4\u0000\u034e"+
		"\u034a\u0001\u0000\u0000\u0000\u034e\u034b\u0001\u0000\u0000\u0000\u034e"+
		"\u034c\u0001\u0000\u0000\u0000\u034e\u034d\u0001\u0000\u0000\u0000\u034f"+
		"\u0351\u0001\u0000\u0000\u0000\u0350\u0352\u0003l6\u0000\u0351\u0350\u0001"+
		"\u0000\u0000\u0000\u0351\u0352\u0001\u0000\u0000\u0000\u0352\u035f\u0001"+
		"\u0000\u0000\u0000\u0353\u0358\u0005\u0004\u0000\u0000\u0354\u0359\u0003"+
		"b1\u0000\u0355\u0359\u0003`0\u0000\u0356\u0359\u0003f3\u0000\u0357\u0359"+
		"\u0003\b\u0004\u0000\u0358\u0354\u0001\u0000\u0000\u0000\u0358\u0355\u0001"+
		"\u0000\u0000\u0000\u0358\u0356\u0001\u0000\u0000\u0000\u0358\u0357\u0001"+
		"\u0000\u0000\u0000\u0359\u035a\u0001\u0000\u0000\u0000\u035a\u035c\u0005"+
		"\u0005\u0000\u0000\u035b\u035d\u0003l6\u0000\u035c\u035b\u0001\u0000\u0000"+
		"\u0000\u035c\u035d\u0001\u0000\u0000\u0000\u035d\u035f\u0001\u0000\u0000"+
		"\u0000\u035e\u034e\u0001\u0000\u0000\u0000\u035e\u0353\u0001\u0000\u0000"+
		"\u0000\u035f\u0363\u0001\u0000\u0000\u0000\u0360\u0362\u0003j5\u0000\u0361"+
		"\u0360\u0001\u0000\u0000\u0000\u0362\u0365\u0001\u0000\u0000\u0000\u0363"+
		"\u0361\u0001\u0000\u0000\u0000\u0363\u0364\u0001\u0000\u0000\u0000\u0364"+
		"\u0367\u0001\u0000\u0000\u0000\u0365\u0363\u0001\u0000\u0000\u0000\u0366"+
		"\u0346\u0001\u0000\u0000\u0000\u0366\u035e\u0001\u0000\u0000\u0000\u0367"+
		"_\u0001\u0000\u0000\u0000\u0368\u036f\u0003x<\u0000\u0369\u036a\u0003"+
		"x<\u0000\u036a\u036b\u0005\u0003\u0000\u0000\u036b\u036c\u0003t:\u0000"+
		"\u036c\u036f\u0001\u0000\u0000\u0000\u036d\u036f\u0003t:\u0000\u036e\u0368"+
		"\u0001\u0000\u0000\u0000\u036e\u0369\u0001\u0000\u0000\u0000\u036e\u036d"+
		"\u0001\u0000\u0000\u0000\u036fa\u0001\u0000\u0000\u0000\u0370\u0371\u0003"+
		"x<\u0000\u0371\u0372\u0005\u0003\u0000\u0000\u0372\u037e\u0007\u0012\u0000"+
		"\u0000\u0373\u0374\u0005\u0004\u0000\u0000\u0374\u0379\u0003d2\u0000\u0375"+
		"\u0376\u0005\u0007\u0000\u0000\u0376\u0378\u0003d2\u0000\u0377\u0375\u0001"+
		"\u0000\u0000\u0000\u0378\u037b\u0001\u0000\u0000\u0000\u0379\u0377\u0001"+
		"\u0000\u0000\u0000\u0379\u037a\u0001\u0000\u0000\u0000\u037a\u037c\u0001"+
		"\u0000\u0000\u0000\u037b\u0379\u0001\u0000\u0000\u0000\u037c\u037d\u0005"+
		"\u0005\u0000\u0000\u037d\u037f\u0001\u0000\u0000\u0000\u037e\u0373\u0001"+
		"\u0000\u0000\u0000\u037e\u037f\u0001\u0000\u0000\u0000\u037f\u038a\u0001"+
		"\u0000\u0000\u0000\u0380\u0381\u0005\u0085\u0000\u0000\u0381\u0382\u0005"+
		"\u0003\u0000\u0000\u0382\u0383\u0003t:\u0000\u0383\u0385\u0005\u0004\u0000"+
		"\u0000\u0384\u0386\u0003v;\u0000\u0385\u0384\u0001\u0000\u0000\u0000\u0385"+
		"\u0386\u0001\u0000\u0000\u0000\u0386\u0387\u0001\u0000\u0000\u0000\u0387"+
		"\u0388\u0005\u0005\u0000\u0000\u0388\u038a\u0001\u0000\u0000\u0000\u0389"+
		"\u0370\u0001\u0000\u0000\u0000\u0389\u0380\u0001\u0000\u0000\u0000\u038a"+
		"c\u0001\u0000\u0000\u0000\u038b\u038d\u0003J%\u0000\u038c\u038b\u0001"+
		"\u0000\u0000\u0000\u038c\u038d\u0001\u0000\u0000\u0000\u038de\u0001\u0000"+
		"\u0000\u0000\u038e\u038f\u0003v;\u0000\u038fg\u0001\u0000\u0000\u0000"+
		"\u0390\u0391\u0003x<\u0000\u0391\u0392\u0005\u0003\u0000\u0000\u0392\u0393"+
		"\u0005\u00b1\u0000\u0000\u0393\u0394\u0005\u0003\u0000\u0000\u0394\u0395"+
		"\u0003t:\u0000\u0395\u03a1\u0001\u0000\u0000\u0000\u0396\u0397\u0003x"+
		"<\u0000\u0397\u0398\u0005\u0003\u0000\u0000\u0398\u0399\u0005\u00b2\u0000"+
		"\u0000\u0399\u039a\u0005\u0003\u0000\u0000\u039a\u039b\u0003t:\u0000\u039b"+
		"\u039c\u0005\u0003\u0000\u0000\u039c\u039d\u0005\u00b3\u0000\u0000\u039d"+
		"\u039e\u0005\u0003\u0000\u0000\u039e\u039f\u0003t:\u0000\u039f\u03a1\u0001"+
		"\u0000\u0000\u0000\u03a0\u0390\u0001\u0000\u0000\u0000\u03a0\u0396\u0001"+
		"\u0000\u0000\u0000\u03a1i\u0001\u0000\u0000\u0000\u03a2\u03a4\u0005\u0090"+
		"\u0000\u0000\u03a3\u03a5\u0005\u0095\u0000\u0000\u03a4\u03a3\u0001\u0000"+
		"\u0000\u0000\u03a4\u03a5\u0001\u0000\u0000\u0000\u03a5\u03a6\u0001\u0000"+
		"\u0000\u0000\u03a6\u03b5\u0005\u0094\u0000\u0000\u03a7\u03a9\u0005\u0091"+
		"\u0000\u0000\u03a8\u03aa\u0005\u0095\u0000\u0000\u03a9\u03a8\u0001\u0000"+
		"\u0000\u0000\u03a9\u03aa\u0001\u0000\u0000\u0000\u03aa\u03ab\u0001\u0000"+
		"\u0000\u0000\u03ab\u03b5\u0005\u0094\u0000\u0000\u03ac\u03ae\u0005\u0093"+
		"\u0000\u0000\u03ad\u03af\u0005\u0095\u0000\u0000\u03ae\u03ad\u0001\u0000"+
		"\u0000\u0000\u03ae\u03af\u0001\u0000\u0000\u0000\u03af\u03b0\u0001\u0000"+
		"\u0000\u0000\u03b0\u03b5\u0005\u0094\u0000\u0000\u03b1\u03b2\u0005\u0092"+
		"\u0000\u0000\u03b2\u03b5\u0005\u0094\u0000\u0000\u03b3\u03b5\u0005\u0094"+
		"\u0000\u0000\u03b4\u03a2\u0001\u0000\u0000\u0000\u03b4\u03a7\u0001\u0000"+
		"\u0000\u0000\u03b4\u03ac\u0001\u0000\u0000\u0000\u03b4\u03b1\u0001\u0000"+
		"\u0000\u0000\u03b4\u03b3\u0001\u0000\u0000\u0000\u03b5\u03b6\u0001\u0000"+
		"\u0000\u0000\u03b6\u03b7\u0003^/\u0000\u03b7\u03b8\u0007\u0013\u0000\u0000"+
		"\u03b8\u03b9\u0003J%\u0000\u03b9k\u0001\u0000\u0000\u0000\u03ba\u03bc"+
		"\u0005\u0016\u0000\u0000\u03bb\u03ba\u0001\u0000\u0000\u0000\u03bb\u03bc"+
		"\u0001\u0000\u0000\u0000\u03bc\u03bd\u0001\u0000\u0000\u0000\u03bd\u03be"+
		"\u0003t:\u0000\u03bem\u0001\u0000\u0000\u0000\u03bf\u03c2\u0003v;\u0000"+
		"\u03c0\u03c2\u0005\u009c\u0000\u0000\u03c1\u03bf\u0001\u0000\u0000\u0000"+
		"\u03c1\u03c0\u0001\u0000\u0000\u0000\u03c2o\u0001\u0000\u0000\u0000\u03c3"+
		"\u03c5\u0005\u009e\u0000\u0000\u03c4\u03c3\u0001\u0000\u0000\u0000\u03c5"+
		"\u03c6\u0001\u0000\u0000\u0000\u03c6\u03c4\u0001\u0000\u0000\u0000\u03c6"+
		"\u03c7\u0001\u0000\u0000\u0000\u03c7q\u0001\u0000\u0000\u0000\u03c8\u03c9"+
		"\u0007\u0014\u0000\u0000\u03c9s\u0001\u0000\u0000\u0000\u03ca\u03cb\u0007"+
		"\u0015\u0000\u0000\u03cbu\u0001\u0000\u0000\u0000\u03cc\u03cd\u0005\u0012"+
		"\u0000\u0000\u03cd\u03ce\u0005\u00a2\u0000\u0000\u03cew\u0001\u0000\u0000"+
		"\u0000\u03cf\u03d0\u0007\u0016\u0000\u0000\u03d0\u03d1\u0005\u0003\u0000"+
		"\u0000\u03d1\u03d2\u0003t:\u0000\u03d2y\u0001\u0000\u0000\u0000i\u007f"+
		"\u0083\u0089\u009e\u00a3\u00a7\u00a9\u00ad\u00b2\u00b4\u00b8\u00bc\u00c0"+
		"\u00c5\u00c9\u00cd\u00d2\u00d6\u00db\u00dd\u00e6\u00e9\u00ee\u0114\u011e"+
		"\u0126\u0129\u0130\u0139\u0146\u0160\u016a\u016d\u0171\u0178\u017e\u0180"+
		"\u0184\u018c\u0192\u0196\u0199\u019b\u01a2\u01a6\u01af\u01b7\u01b9\u01c2"+
		"\u01c9\u01e0\u01ec\u01ef\u01f6\u01fa\u0202\u0206\u020d\u0211\u0220\u022c"+
		"\u0234\u0237\u0292\u029c\u02a0\u02a3\u02c2\u02d0\u02d3\u02d9\u02dd\u02e6"+
		"\u02ec\u02fa\u0300\u0307\u030c\u031f\u0324\u0329\u032e\u033b\u0343\u034e"+
		"\u0351\u0358\u035c\u035e\u0363\u0366\u036e\u0379\u037e\u0385\u0389\u038c"+
		"\u03a0\u03a4\u03a9\u03ae\u03b4\u03bb\u03c1\u03c6";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}