13324 lines
480 KiB
Java
13324 lines
480 KiB
Java
// Generated from ./MathExpr.g4 by ANTLR 4.13.2
|
|
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", "this-escape"})
|
|
public class MathExprParser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }
|
|
|
|
protected static final DFA[] _decisionToDFA;
|
|
protected static final PredictionContextCache _sharedContextCache =
|
|
new PredictionContextCache();
|
|
public static final int
|
|
SIN=1, COS=2, TAN=3, ASIN=4, ACOS=5, ATAN=6, ATAN2=7, SINH=8, COSH=9,
|
|
TANH=10, ASINH=11, ACOSH=12, ATANH=13, ABS=14, SQRT=15, LN=16, LOG=17,
|
|
EXP=18, SMIN=19, SMAX=20, TMIN=21, TMAX=22, TNORM=23, SNORM=24, FLOOR=25,
|
|
CEIL=26, ROUND=27, GAMMA=28, POWE=29, SIGM=30, CLAMP=31, SFFT=32, SIFFT=33,
|
|
ANGL=34, PRNT=35, PRINT_SHAPE=36, NVL=37, LERP=38, STEP=39, SMOOTHSTEP=40,
|
|
FRACT=41, RELU=42, SOFTPLUS=43, GELU=44, SIGN=45, MAP=46, EZCONV=47, CONV=48,
|
|
SWAP=49, PERM=50, RESHAPE=51, RANGE=52, LINSPACE=53, LOGSPACE=54, TOPK=55,
|
|
BOTK=56, PINV=57, SUM=58, MEAN=59, STD=60, VAR=61, QUARTILE=62, PERCENTILE=63,
|
|
QUANTILE=64, DOT=65, MOMENT=66, ERF=67, ERFINV=68, ANY=69, ALL=70, EDGE=71,
|
|
GAUSSIAN=72, MEDIAN=73, MODE=74, CUMSUM=75, CUMPROD=76, TOPK_IND=77, BOTK_IND=78,
|
|
CUBIC_EASE=79, ELASTIC_EASE=80, SINE_EASE=81, SMOOTHERSTEP=82, DIST=83,
|
|
REMAP=84, COSSIM=85, COUNT=86, FLATTEN=87, APPEND=88, GET_VALUE=89, FLOW_APPLY=90,
|
|
BATCH_SHUFFLE=91, MOTION_MASK=92, FLOW_TO_IMAGE=93, FLOW_MAG=94, FLOW_ANG=95,
|
|
WHERE=96, HISTOGRAM=97, OVERLAY=98, PAD=99, CROSS=100, MATMUL=101, RIFE=102,
|
|
BNOT=103, BITCOUNT=104, SHAPE=105, BAND=106, XOR=107, BOR=108, TENSOR=109,
|
|
PUSH=110, POP=111, CLEAR=112, HAS=113, GET=114, CONCAT=115, INT=116, FLOAT=117,
|
|
UPPER=118, LOWER=119, TRIM=120, SPLIT=121, JOIN=122, SUBSTRING=123, SUBSTR=124,
|
|
FIND=125, REPLACE=126, DILATE=127, ERODE=128, MORPH_OPEN=129, MORPH_CLOSE=130,
|
|
RGB_TO_OKLAB=131, RGB_TO_CILAB=132, OKLAB_TO_RGB=133, CILAB_TO_RGB=134,
|
|
RGB_TO_HSV=135, HSV_TO_RGB=136, INT_TO_RGB=137, RGB_TO_INT=138, INTERPOLATE_LINEAR=139,
|
|
INTERPOLATE_AREA=140, INTERPOLATE_NEAREST=141, IF=142, ELSE=143, WHILE=144,
|
|
FOR=145, IN=146, BREAK=147, CONTINUE=148, RETURN=149, TIMESTAMP=150, SORT=151,
|
|
ARGSORT=152, ARGMIN=153, ARGMAX=154, SOFTMAX=155, SOFTMIN=156, UNIQUE=157,
|
|
FLIP=158, ROLL=159, COV=160, CORR=161, ENTROPY=162, CROP=163, NONE=164,
|
|
NOISE=165, RAND=166, CAUCHY=167, EXPONENTIAL=168, LOGNORMAL=169, BERNOULLI=170,
|
|
POISSON=171, GAMMADIST=172, BETADIST=173, LAPLACEDIST=174, GUMBELDIST=175,
|
|
WEIBULLDIST=176, CHI2DIST=177, STUDENTTDIST=178, PERLIN=179, CELLULAR=180,
|
|
PLASMA=181, PLUS=182, MINUS=183, MULT=184, DIV=185, MOD=186, POW=187,
|
|
LSHIFT=188, RSHIFT=189, GE=190, GT=191, LE=192, LT=193, EQ=194, EQUEALS=195,
|
|
PLUS_EQ=196, MINUS_EQ=197, MULT_EQ=198, DIV_EQ=199, MOD_EQ=200, NE=201,
|
|
PIPE=202, LPAREN=203, RPAREN=204, COMMA=205, SEMICOLON=206, ARROW=207,
|
|
LBRACKET=208, RBRACKET=209, QUESTION=210, COLON=211, LBRACE=212, RBRACE=213,
|
|
NUMBER=214, CONSTANT=215, STRING=216, VARIABLE=217, SL_COMMENT=218, ML_COMMENT=219,
|
|
WS=220;
|
|
public static final int
|
|
RULE_start = 0, RULE_funcDef = 1, RULE_varDef = 2, RULE_paramList = 3,
|
|
RULE_stmt = 4, RULE_ifStmt = 5, RULE_whileStmt = 6, RULE_forStmt = 7,
|
|
RULE_block = 8, RULE_breakStmt = 9, RULE_continueStmt = 10, RULE_returnStmt = 11,
|
|
RULE_expr = 12, RULE_ternaryExpr = 13, RULE_compExpr = 14, RULE_addExpr = 15,
|
|
RULE_mulExpr = 16, RULE_shiftExpr = 17, RULE_powExpr = 18, RULE_unaryExpr = 19,
|
|
RULE_indexExpr = 20, RULE_atom = 21, RULE_exprList = 22, RULE_func0 = 23,
|
|
RULE_func1 = 24, RULE_func2 = 25, RULE_func3 = 26, RULE_func4 = 27, RULE_func5 = 28,
|
|
RULE_funcN = 29, RULE_funcNoise = 30;
|
|
private static String[] makeRuleNames() {
|
|
return new String[] {
|
|
"start", "funcDef", "varDef", "paramList", "stmt", "ifStmt", "whileStmt",
|
|
"forStmt", "block", "breakStmt", "continueStmt", "returnStmt", "expr",
|
|
"ternaryExpr", "compExpr", "addExpr", "mulExpr", "shiftExpr", "powExpr",
|
|
"unaryExpr", "indexExpr", "atom", "exprList", "func0", "func1", "func2",
|
|
"func3", "func4", "func5", "funcN", "funcNoise"
|
|
};
|
|
}
|
|
public static final String[] ruleNames = makeRuleNames();
|
|
|
|
private static String[] makeLiteralNames() {
|
|
return new String[] {
|
|
null, "'sin'", "'cos'", "'tan'", "'asin'", "'acos'", "'atan'", "'atan2'",
|
|
"'sinh'", "'cosh'", "'tanh'", "'asinh'", "'acosh'", "'atanh'", "'abs'",
|
|
"'sqrt'", "'ln'", "'log'", "'exp'", "'smin'", "'smax'", "'tmin'", "'tmax'",
|
|
"'tnorm'", "'snorm'", "'floor'", "'ceil'", "'round'", "'gamma'", "'pow'",
|
|
"'sigm'", "'clamp'", "'fft'", "'ifft'", "'angle'", "'print'", null, null,
|
|
"'lerp'", "'step'", "'smoothstep'", "'fract'", "'relu'", "'softplus'",
|
|
"'gelu'", "'sign'", "'map'", null, null, "'swap'", null, null, "'range'",
|
|
"'linspace'", "'logspace'", "'topk'", "'botk'", "'pinv'", "'sum'", "'mean'",
|
|
"'std'", "'var'", null, null, "'quantile'", "'dot'", "'moment'", "'erf'",
|
|
"'erfinv'", "'any'", "'all'", "'edge'", null, "'median'", "'mode'", "'cumsum'",
|
|
"'cumprod'", null, null, null, null, null, "'smootherstep'", null, "'remap'",
|
|
null, null, "'flatten'", "'append'", "'get_value'", "'flow_apply'", null,
|
|
"'motion_mask'", "'flow_to_image'", null, null, "'where'", null, "'overlay'",
|
|
"'pad'", "'cross'", "'matmul'", "'rife'", null, null, "'shape'", null,
|
|
null, null, "'tensor'", "'stack_push'", "'stack_pop'", "'stack_clear'",
|
|
"'stack_has'", "'stack_get'", null, "'int'", "'float'", "'upper'", "'lower'",
|
|
"'trim'", "'split'", "'join'", "'substring'", "'substr'", "'find'", "'replace'",
|
|
"'dilate'", "'erode'", "'morph_open'", "'morph_close'", "'rgb_to_oklab'",
|
|
"'rgb_to_cilab'", "'oklab_to_rgb'", "'cielab_to_rgb'", "'rgb_to_hsv'",
|
|
"'hsv_to_rgb'", "'int_to_rgb'", "'rgb_to_int'", "'interpolate_linear'",
|
|
"'interpolate_area'", null, "'if'", "'else'", "'while'", "'for'", "'in'",
|
|
"'break'", "'continue'", "'return'", null, "'sort'", "'argsort'", "'argmin'",
|
|
"'argmax'", "'softmax'", "'softmin'", "'unique'", "'flip'", "'roll'",
|
|
"'cov'", null, "'entropy'", "'crop'", 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, "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "ATAN2", "SINH", "COSH",
|
|
"TANH", "ASINH", "ACOSH", "ATANH", "ABS", "SQRT", "LN", "LOG", "EXP",
|
|
"SMIN", "SMAX", "TMIN", "TMAX", "TNORM", "SNORM", "FLOOR", "CEIL", "ROUND",
|
|
"GAMMA", "POWE", "SIGM", "CLAMP", "SFFT", "SIFFT", "ANGL", "PRNT", "PRINT_SHAPE",
|
|
"NVL", "LERP", "STEP", "SMOOTHSTEP", "FRACT", "RELU", "SOFTPLUS", "GELU",
|
|
"SIGN", "MAP", "EZCONV", "CONV", "SWAP", "PERM", "RESHAPE", "RANGE",
|
|
"LINSPACE", "LOGSPACE", "TOPK", "BOTK", "PINV", "SUM", "MEAN", "STD",
|
|
"VAR", "QUARTILE", "PERCENTILE", "QUANTILE", "DOT", "MOMENT", "ERF",
|
|
"ERFINV", "ANY", "ALL", "EDGE", "GAUSSIAN", "MEDIAN", "MODE", "CUMSUM",
|
|
"CUMPROD", "TOPK_IND", "BOTK_IND", "CUBIC_EASE", "ELASTIC_EASE", "SINE_EASE",
|
|
"SMOOTHERSTEP", "DIST", "REMAP", "COSSIM", "COUNT", "FLATTEN", "APPEND",
|
|
"GET_VALUE", "FLOW_APPLY", "BATCH_SHUFFLE", "MOTION_MASK", "FLOW_TO_IMAGE",
|
|
"FLOW_MAG", "FLOW_ANG", "WHERE", "HISTOGRAM", "OVERLAY", "PAD", "CROSS",
|
|
"MATMUL", "RIFE", "BNOT", "BITCOUNT", "SHAPE", "BAND", "XOR", "BOR",
|
|
"TENSOR", "PUSH", "POP", "CLEAR", "HAS", "GET", "CONCAT", "INT", "FLOAT",
|
|
"UPPER", "LOWER", "TRIM", "SPLIT", "JOIN", "SUBSTRING", "SUBSTR", "FIND",
|
|
"REPLACE", "DILATE", "ERODE", "MORPH_OPEN", "MORPH_CLOSE", "RGB_TO_OKLAB",
|
|
"RGB_TO_CILAB", "OKLAB_TO_RGB", "CILAB_TO_RGB", "RGB_TO_HSV", "HSV_TO_RGB",
|
|
"INT_TO_RGB", "RGB_TO_INT", "INTERPOLATE_LINEAR", "INTERPOLATE_AREA",
|
|
"INTERPOLATE_NEAREST", "IF", "ELSE", "WHILE", "FOR", "IN", "BREAK", "CONTINUE",
|
|
"RETURN", "TIMESTAMP", "SORT", "ARGSORT", "ARGMIN", "ARGMAX", "SOFTMAX",
|
|
"SOFTMIN", "UNIQUE", "FLIP", "ROLL", "COV", "CORR", "ENTROPY", "CROP",
|
|
"NONE", "NOISE", "RAND", "CAUCHY", "EXPONENTIAL", "LOGNORMAL", "BERNOULLI",
|
|
"POISSON", "GAMMADIST", "BETADIST", "LAPLACEDIST", "GUMBELDIST", "WEIBULLDIST",
|
|
"CHI2DIST", "STUDENTTDIST", "PERLIN", "CELLULAR", "PLASMA", "PLUS", "MINUS",
|
|
"MULT", "DIV", "MOD", "POW", "LSHIFT", "RSHIFT", "GE", "GT", "LE", "LT",
|
|
"EQ", "EQUEALS", "PLUS_EQ", "MINUS_EQ", "MULT_EQ", "DIV_EQ", "MOD_EQ",
|
|
"NE", "PIPE", "LPAREN", "RPAREN", "COMMA", "SEMICOLON", "ARROW", "LBRACKET",
|
|
"RBRACKET", "QUESTION", "COLON", "LBRACE", "RBRACE", "NUMBER", "CONSTANT",
|
|
"STRING", "VARIABLE", "SL_COMMENT", "ML_COMMENT", "WS"
|
|
};
|
|
}
|
|
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] = "<INVALID>";
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Deprecated
|
|
public String[] getTokenNames() {
|
|
return tokenNames;
|
|
}
|
|
|
|
@Override
|
|
|
|
public Vocabulary getVocabulary() {
|
|
return VOCABULARY;
|
|
}
|
|
|
|
@Override
|
|
public String getGrammarFileName() { return "MathExpr.g4"; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public MathExprParser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StartContext extends ParserRuleContext {
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode EOF() { return getToken(MathExprParser.EOF, 0); }
|
|
public List<FuncDefContext> funcDef() {
|
|
return getRuleContexts(FuncDefContext.class);
|
|
}
|
|
public FuncDefContext funcDef(int i) {
|
|
return getRuleContext(FuncDefContext.class,i);
|
|
}
|
|
public List<VarDefContext> varDef() {
|
|
return getRuleContexts(VarDefContext.class);
|
|
}
|
|
public VarDefContext varDef(int i) {
|
|
return getRuleContext(VarDefContext.class,i);
|
|
}
|
|
public List<StmtContext> stmt() {
|
|
return getRuleContexts(StmtContext.class);
|
|
}
|
|
public StmtContext stmt(int i) {
|
|
return getRuleContext(StmtContext.class,i);
|
|
}
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public StartContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_start; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterStart(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitStart(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitStart(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final StartContext start() throws RecognitionException {
|
|
StartContext _localctx = new StartContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_start);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(67);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
setState(65);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(62);
|
|
funcDef();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(63);
|
|
varDef();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
setState(64);
|
|
stmt();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(69);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
|
|
}
|
|
setState(70);
|
|
expr();
|
|
setState(72);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==SEMICOLON) {
|
|
{
|
|
setState(71);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
|
|
setState(74);
|
|
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 FuncDefContext extends ParserRuleContext {
|
|
public FuncDefContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_funcDef; }
|
|
|
|
public FuncDefContext() { }
|
|
public void copyFrom(FuncDefContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FunctionDefContext extends FuncDefContext {
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode ARROW() { return getToken(MathExprParser.ARROW, 0); }
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public ParamListContext paramList() {
|
|
return getRuleContext(ParamListContext.class,0);
|
|
}
|
|
public FunctionDefContext(FuncDefContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunctionDef(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunctionDef(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunctionDef(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FuncDefContext funcDef() throws RecognitionException {
|
|
FuncDefContext _localctx = new FuncDefContext(_ctx, getState());
|
|
enterRule(_localctx, 2, RULE_funcDef);
|
|
int _la;
|
|
try {
|
|
_localctx = new FunctionDefContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(76);
|
|
match(VARIABLE);
|
|
setState(77);
|
|
match(LPAREN);
|
|
setState(79);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==VARIABLE) {
|
|
{
|
|
setState(78);
|
|
paramList();
|
|
}
|
|
}
|
|
|
|
setState(81);
|
|
match(RPAREN);
|
|
setState(82);
|
|
match(ARROW);
|
|
setState(85);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
{
|
|
setState(83);
|
|
block();
|
|
}
|
|
break;
|
|
case SIN:
|
|
case COS:
|
|
case TAN:
|
|
case ASIN:
|
|
case ACOS:
|
|
case ATAN:
|
|
case ATAN2:
|
|
case SINH:
|
|
case COSH:
|
|
case TANH:
|
|
case ASINH:
|
|
case ACOSH:
|
|
case ATANH:
|
|
case ABS:
|
|
case SQRT:
|
|
case LN:
|
|
case LOG:
|
|
case EXP:
|
|
case SMIN:
|
|
case SMAX:
|
|
case TMIN:
|
|
case TMAX:
|
|
case TNORM:
|
|
case SNORM:
|
|
case FLOOR:
|
|
case CEIL:
|
|
case ROUND:
|
|
case GAMMA:
|
|
case POWE:
|
|
case SIGM:
|
|
case CLAMP:
|
|
case SFFT:
|
|
case SIFFT:
|
|
case ANGL:
|
|
case PRNT:
|
|
case PRINT_SHAPE:
|
|
case NVL:
|
|
case LERP:
|
|
case STEP:
|
|
case SMOOTHSTEP:
|
|
case FRACT:
|
|
case RELU:
|
|
case SOFTPLUS:
|
|
case GELU:
|
|
case SIGN:
|
|
case MAP:
|
|
case EZCONV:
|
|
case CONV:
|
|
case SWAP:
|
|
case PERM:
|
|
case RESHAPE:
|
|
case RANGE:
|
|
case LINSPACE:
|
|
case LOGSPACE:
|
|
case TOPK:
|
|
case BOTK:
|
|
case PINV:
|
|
case SUM:
|
|
case MEAN:
|
|
case STD:
|
|
case VAR:
|
|
case QUARTILE:
|
|
case PERCENTILE:
|
|
case QUANTILE:
|
|
case DOT:
|
|
case MOMENT:
|
|
case ERF:
|
|
case ERFINV:
|
|
case ANY:
|
|
case ALL:
|
|
case EDGE:
|
|
case GAUSSIAN:
|
|
case MEDIAN:
|
|
case MODE:
|
|
case CUMSUM:
|
|
case CUMPROD:
|
|
case TOPK_IND:
|
|
case BOTK_IND:
|
|
case CUBIC_EASE:
|
|
case ELASTIC_EASE:
|
|
case SINE_EASE:
|
|
case SMOOTHERSTEP:
|
|
case DIST:
|
|
case REMAP:
|
|
case COSSIM:
|
|
case COUNT:
|
|
case FLATTEN:
|
|
case APPEND:
|
|
case GET_VALUE:
|
|
case FLOW_APPLY:
|
|
case BATCH_SHUFFLE:
|
|
case MOTION_MASK:
|
|
case FLOW_TO_IMAGE:
|
|
case FLOW_MAG:
|
|
case FLOW_ANG:
|
|
case WHERE:
|
|
case HISTOGRAM:
|
|
case OVERLAY:
|
|
case PAD:
|
|
case CROSS:
|
|
case MATMUL:
|
|
case RIFE:
|
|
case BNOT:
|
|
case BITCOUNT:
|
|
case SHAPE:
|
|
case BAND:
|
|
case XOR:
|
|
case BOR:
|
|
case TENSOR:
|
|
case PUSH:
|
|
case POP:
|
|
case CLEAR:
|
|
case HAS:
|
|
case GET:
|
|
case CONCAT:
|
|
case INT:
|
|
case FLOAT:
|
|
case UPPER:
|
|
case LOWER:
|
|
case TRIM:
|
|
case SPLIT:
|
|
case JOIN:
|
|
case SUBSTRING:
|
|
case SUBSTR:
|
|
case FIND:
|
|
case REPLACE:
|
|
case DILATE:
|
|
case ERODE:
|
|
case MORPH_OPEN:
|
|
case MORPH_CLOSE:
|
|
case RGB_TO_OKLAB:
|
|
case RGB_TO_CILAB:
|
|
case OKLAB_TO_RGB:
|
|
case CILAB_TO_RGB:
|
|
case RGB_TO_HSV:
|
|
case HSV_TO_RGB:
|
|
case INT_TO_RGB:
|
|
case RGB_TO_INT:
|
|
case INTERPOLATE_LINEAR:
|
|
case INTERPOLATE_AREA:
|
|
case INTERPOLATE_NEAREST:
|
|
case BREAK:
|
|
case CONTINUE:
|
|
case TIMESTAMP:
|
|
case SORT:
|
|
case ARGSORT:
|
|
case ARGMIN:
|
|
case ARGMAX:
|
|
case SOFTMAX:
|
|
case SOFTMIN:
|
|
case UNIQUE:
|
|
case FLIP:
|
|
case ROLL:
|
|
case COV:
|
|
case CORR:
|
|
case ENTROPY:
|
|
case CROP:
|
|
case NONE:
|
|
case NOISE:
|
|
case RAND:
|
|
case CAUCHY:
|
|
case EXPONENTIAL:
|
|
case LOGNORMAL:
|
|
case BERNOULLI:
|
|
case POISSON:
|
|
case GAMMADIST:
|
|
case BETADIST:
|
|
case LAPLACEDIST:
|
|
case GUMBELDIST:
|
|
case WEIBULLDIST:
|
|
case CHI2DIST:
|
|
case STUDENTTDIST:
|
|
case PERLIN:
|
|
case CELLULAR:
|
|
case PLASMA:
|
|
case PLUS:
|
|
case MINUS:
|
|
case PIPE:
|
|
case LPAREN:
|
|
case LBRACKET:
|
|
case NUMBER:
|
|
case CONSTANT:
|
|
case STRING:
|
|
case VARIABLE:
|
|
{
|
|
setState(84);
|
|
expr();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
setState(87);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VarDefContext extends ParserRuleContext {
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public TerminalNode EQUEALS() { return getToken(MathExprParser.EQUEALS, 0); }
|
|
public TerminalNode PLUS_EQ() { return getToken(MathExprParser.PLUS_EQ, 0); }
|
|
public TerminalNode MINUS_EQ() { return getToken(MathExprParser.MINUS_EQ, 0); }
|
|
public TerminalNode MULT_EQ() { return getToken(MathExprParser.MULT_EQ, 0); }
|
|
public TerminalNode DIV_EQ() { return getToken(MathExprParser.DIV_EQ, 0); }
|
|
public TerminalNode MOD_EQ() { return getToken(MathExprParser.MOD_EQ, 0); }
|
|
public List<TerminalNode> LBRACKET() { return getTokens(MathExprParser.LBRACKET); }
|
|
public TerminalNode LBRACKET(int i) {
|
|
return getToken(MathExprParser.LBRACKET, i);
|
|
}
|
|
public List<TerminalNode> RBRACKET() { return getTokens(MathExprParser.RBRACKET); }
|
|
public TerminalNode RBRACKET(int i) {
|
|
return getToken(MathExprParser.RBRACKET, i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public VarDefContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_varDef; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterVarDef(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitVarDef(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitVarDef(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VarDefContext varDef() throws RecognitionException {
|
|
VarDefContext _localctx = new VarDefContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_varDef);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(89);
|
|
match(VARIABLE);
|
|
setState(103);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACKET) {
|
|
{
|
|
{
|
|
setState(90);
|
|
match(LBRACKET);
|
|
setState(91);
|
|
expr();
|
|
setState(96);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(92);
|
|
match(COMMA);
|
|
setState(93);
|
|
expr();
|
|
}
|
|
}
|
|
setState(98);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(99);
|
|
match(RBRACKET);
|
|
}
|
|
}
|
|
setState(105);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(106);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 195)) & ~0x3f) == 0 && ((1L << (_la - 195)) & 63L) != 0)) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(107);
|
|
expr();
|
|
setState(108);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ParamListContext extends ParserRuleContext {
|
|
public List<TerminalNode> VARIABLE() { return getTokens(MathExprParser.VARIABLE); }
|
|
public TerminalNode VARIABLE(int i) {
|
|
return getToken(MathExprParser.VARIABLE, i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public ParamListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_paramList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterParamList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitParamList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitParamList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ParamListContext paramList() throws RecognitionException {
|
|
ParamListContext _localctx = new ParamListContext(_ctx, getState());
|
|
enterRule(_localctx, 6, RULE_paramList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(110);
|
|
match(VARIABLE);
|
|
setState(115);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(111);
|
|
match(COMMA);
|
|
setState(112);
|
|
match(VARIABLE);
|
|
}
|
|
}
|
|
setState(117);
|
|
_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 StmtContext extends ParserRuleContext {
|
|
public StmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_stmt; }
|
|
|
|
public StmtContext() { }
|
|
public void copyFrom(StmtContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BreakStatementContext extends StmtContext {
|
|
public BreakStmtContext breakStmt() {
|
|
return getRuleContext(BreakStmtContext.class,0);
|
|
}
|
|
public BreakStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBreakStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBreakStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBreakStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VarDefStmtContext extends StmtContext {
|
|
public VarDefContext varDef() {
|
|
return getRuleContext(VarDefContext.class,0);
|
|
}
|
|
public VarDefStmtContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterVarDefStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitVarDefStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitVarDefStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IfStatementContext extends StmtContext {
|
|
public IfStmtContext ifStmt() {
|
|
return getRuleContext(IfStmtContext.class,0);
|
|
}
|
|
public IfStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterIfStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitIfStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitIfStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReturnStatementContext extends StmtContext {
|
|
public ReturnStmtContext returnStmt() {
|
|
return getRuleContext(ReturnStmtContext.class,0);
|
|
}
|
|
public ReturnStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterReturnStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitReturnStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitReturnStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExprStatementContext extends StmtContext {
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public ExprStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterExprStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitExprStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitExprStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockStatementContext extends StmtContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public BlockStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBlockStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBlockStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBlockStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhileStatementContext extends StmtContext {
|
|
public WhileStmtContext whileStmt() {
|
|
return getRuleContext(WhileStmtContext.class,0);
|
|
}
|
|
public WhileStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterWhileStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitWhileStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitWhileStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForStatementContext extends StmtContext {
|
|
public ForStmtContext forStmt() {
|
|
return getRuleContext(ForStmtContext.class,0);
|
|
}
|
|
public ForStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterForStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitForStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitForStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ContinueStatementContext extends StmtContext {
|
|
public ContinueStmtContext continueStmt() {
|
|
return getRuleContext(ContinueStmtContext.class,0);
|
|
}
|
|
public ContinueStatementContext(StmtContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterContinueStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitContinueStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitContinueStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final StmtContext stmt() throws RecognitionException {
|
|
StmtContext _localctx = new StmtContext(_ctx, getState());
|
|
enterRule(_localctx, 8, RULE_stmt);
|
|
try {
|
|
setState(129);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
|
|
case 1:
|
|
_localctx = new IfStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(118);
|
|
ifStmt();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new WhileStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(119);
|
|
whileStmt();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new BlockStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(120);
|
|
block();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new BreakStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(121);
|
|
breakStmt();
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new ContinueStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(122);
|
|
continueStmt();
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new ReturnStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(123);
|
|
returnStmt();
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new VarDefStmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(124);
|
|
varDef();
|
|
}
|
|
break;
|
|
case 8:
|
|
_localctx = new ForStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(125);
|
|
forStmt();
|
|
}
|
|
break;
|
|
case 9:
|
|
_localctx = new ExprStatementContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(126);
|
|
expr();
|
|
setState(127);
|
|
match(SEMICOLON);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IfStmtContext extends ParserRuleContext {
|
|
public TerminalNode IF() { return getToken(MathExprParser.IF, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<StmtContext> stmt() {
|
|
return getRuleContexts(StmtContext.class);
|
|
}
|
|
public StmtContext stmt(int i) {
|
|
return getRuleContext(StmtContext.class,i);
|
|
}
|
|
public TerminalNode ELSE() { return getToken(MathExprParser.ELSE, 0); }
|
|
public IfStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ifStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterIfStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitIfStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitIfStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final IfStmtContext ifStmt() throws RecognitionException {
|
|
IfStmtContext _localctx = new IfStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 10, RULE_ifStmt);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(131);
|
|
match(IF);
|
|
setState(132);
|
|
match(LPAREN);
|
|
setState(133);
|
|
expr();
|
|
setState(134);
|
|
match(RPAREN);
|
|
setState(135);
|
|
stmt();
|
|
setState(138);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(136);
|
|
match(ELSE);
|
|
setState(137);
|
|
stmt();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhileStmtContext extends ParserRuleContext {
|
|
public TerminalNode WHILE() { return getToken(MathExprParser.WHILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public StmtContext stmt() {
|
|
return getRuleContext(StmtContext.class,0);
|
|
}
|
|
public WhileStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_whileStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterWhileStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitWhileStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitWhileStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final WhileStmtContext whileStmt() throws RecognitionException {
|
|
WhileStmtContext _localctx = new WhileStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 12, RULE_whileStmt);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(140);
|
|
match(WHILE);
|
|
setState(141);
|
|
match(LPAREN);
|
|
setState(142);
|
|
expr();
|
|
setState(143);
|
|
match(RPAREN);
|
|
setState(144);
|
|
stmt();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForStmtContext extends ParserRuleContext {
|
|
public TerminalNode FOR() { return getToken(MathExprParser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public TerminalNode IN() { return getToken(MathExprParser.IN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public StmtContext stmt() {
|
|
return getRuleContext(StmtContext.class,0);
|
|
}
|
|
public ForStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterForStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitForStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitForStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ForStmtContext forStmt() throws RecognitionException {
|
|
ForStmtContext _localctx = new ForStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 14, RULE_forStmt);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(146);
|
|
match(FOR);
|
|
setState(147);
|
|
match(LPAREN);
|
|
setState(148);
|
|
match(VARIABLE);
|
|
setState(149);
|
|
match(IN);
|
|
setState(150);
|
|
expr();
|
|
setState(151);
|
|
match(RPAREN);
|
|
setState(152);
|
|
stmt();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(MathExprParser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(MathExprParser.RBRACE, 0); }
|
|
public List<StmtContext> stmt() {
|
|
return getRuleContexts(StmtContext.class);
|
|
}
|
|
public StmtContext stmt(int i) {
|
|
return getRuleContext(StmtContext.class,i);
|
|
}
|
|
public BlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_block; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBlock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBlock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBlock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final BlockContext block() throws RecognitionException {
|
|
BlockContext _localctx = new BlockContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_block);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(154);
|
|
match(LBRACE);
|
|
setState(158);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 72057594037633023L) != 0) || ((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & 62531L) != 0)) {
|
|
{
|
|
{
|
|
setState(155);
|
|
stmt();
|
|
}
|
|
}
|
|
setState(160);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(161);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BreakStmtContext extends ParserRuleContext {
|
|
public TerminalNode BREAK() { return getToken(MathExprParser.BREAK, 0); }
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public BreakStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_breakStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBreakStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBreakStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBreakStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final BreakStmtContext breakStmt() throws RecognitionException {
|
|
BreakStmtContext _localctx = new BreakStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 18, RULE_breakStmt);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(163);
|
|
match(BREAK);
|
|
setState(164);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ContinueStmtContext extends ParserRuleContext {
|
|
public TerminalNode CONTINUE() { return getToken(MathExprParser.CONTINUE, 0); }
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public ContinueStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_continueStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterContinueStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitContinueStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitContinueStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ContinueStmtContext continueStmt() throws RecognitionException {
|
|
ContinueStmtContext _localctx = new ContinueStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 20, RULE_continueStmt);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(166);
|
|
match(CONTINUE);
|
|
setState(167);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReturnStmtContext extends ParserRuleContext {
|
|
public TerminalNode RETURN() { return getToken(MathExprParser.RETURN, 0); }
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public ReturnStmtContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_returnStmt; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterReturnStmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitReturnStmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitReturnStmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ReturnStmtContext returnStmt() throws RecognitionException {
|
|
ReturnStmtContext _localctx = new ReturnStmtContext(_ctx, getState());
|
|
enterRule(_localctx, 22, RULE_returnStmt);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(169);
|
|
match(RETURN);
|
|
setState(171);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 72057594035322879L) != 0) || ((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & 61507L) != 0)) {
|
|
{
|
|
setState(170);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(173);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExprContext extends ParserRuleContext {
|
|
public TernaryExprContext ternaryExpr() {
|
|
return getRuleContext(TernaryExprContext.class,0);
|
|
}
|
|
public AtomContext atom() {
|
|
return getRuleContext(AtomContext.class,0);
|
|
}
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public ExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expr; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitExpr(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitExpr(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExprContext expr() throws RecognitionException {
|
|
ExprContext _localctx = new ExprContext(_ctx, getState());
|
|
enterRule(_localctx, 24, RULE_expr);
|
|
try {
|
|
setState(178);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(175);
|
|
ternaryExpr();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(176);
|
|
atom();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(177);
|
|
compExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TernaryExprContext extends ParserRuleContext {
|
|
public TernaryExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ternaryExpr; }
|
|
|
|
public TernaryExprContext() { }
|
|
public void copyFrom(TernaryExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TernaryExpContext extends TernaryExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode QUESTION() { return getToken(MathExprParser.QUESTION, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COLON() { return getToken(MathExprParser.COLON, 0); }
|
|
public TernaryExpContext(TernaryExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTernaryExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTernaryExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTernaryExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TernaryExprContext ternaryExpr() throws RecognitionException {
|
|
TernaryExprContext _localctx = new TernaryExprContext(_ctx, getState());
|
|
enterRule(_localctx, 26, RULE_ternaryExpr);
|
|
try {
|
|
_localctx = new TernaryExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(180);
|
|
compExpr(0);
|
|
setState(181);
|
|
match(QUESTION);
|
|
setState(182);
|
|
expr();
|
|
setState(183);
|
|
match(COLON);
|
|
setState(184);
|
|
expr();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CompExprContext extends ParserRuleContext {
|
|
public CompExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_compExpr; }
|
|
|
|
public CompExprContext() { }
|
|
public void copyFrom(CompExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LtExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode LT() { return getToken(MathExprParser.LT, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public LtExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLtExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLtExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLtExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EqExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode EQ() { return getToken(MathExprParser.EQ, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public EqExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterEqExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitEqExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitEqExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToAddContext extends CompExprContext {
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public ToAddContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToAdd(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToAdd(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToAdd(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GeExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode GE() { return getToken(MathExprParser.GE, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public GeExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGeExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGeExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGeExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LeExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode LE() { return getToken(MathExprParser.LE, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public LeExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLeExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLeExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLeExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NeExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode NE() { return getToken(MathExprParser.NE, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public NeExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterNeExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitNeExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitNeExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GtExpContext extends CompExprContext {
|
|
public CompExprContext compExpr() {
|
|
return getRuleContext(CompExprContext.class,0);
|
|
}
|
|
public TerminalNode GT() { return getToken(MathExprParser.GT, 0); }
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public GtExpContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGtExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGtExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGtExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final CompExprContext compExpr() throws RecognitionException {
|
|
return compExpr(0);
|
|
}
|
|
|
|
private CompExprContext compExpr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
CompExprContext _localctx = new CompExprContext(_ctx, _parentState);
|
|
CompExprContext _prevctx = _localctx;
|
|
int _startState = 28;
|
|
enterRecursionRule(_localctx, 28, RULE_compExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToAddContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(187);
|
|
addExpr(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(209);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(207);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new GtExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(189);
|
|
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(190);
|
|
match(GT);
|
|
setState(191);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new GeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(192);
|
|
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(193);
|
|
match(GE);
|
|
setState(194);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new LtExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(195);
|
|
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(196);
|
|
match(LT);
|
|
setState(197);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new LeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(198);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(199);
|
|
match(LE);
|
|
setState(200);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new EqExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(201);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(202);
|
|
match(EQ);
|
|
setState(203);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new NeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(204);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(205);
|
|
match(NE);
|
|
setState(206);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(211);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,14,_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 AddExprContext extends ParserRuleContext {
|
|
public AddExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_addExpr; }
|
|
|
|
public AddExprContext() { }
|
|
public void copyFrom(AddExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AddExpContext extends AddExprContext {
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public TerminalNode PLUS() { return getToken(MathExprParser.PLUS, 0); }
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public AddExpContext(AddExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAddExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAddExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAddExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToMulContext extends AddExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public ToMulContext(AddExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToMul(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToMul(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToMul(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SubExpContext extends AddExprContext {
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public TerminalNode MINUS() { return getToken(MathExprParser.MINUS, 0); }
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public SubExpContext(AddExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSubExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSubExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSubExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AddExprContext addExpr() throws RecognitionException {
|
|
return addExpr(0);
|
|
}
|
|
|
|
private AddExprContext addExpr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
AddExprContext _localctx = new AddExprContext(_ctx, _parentState);
|
|
AddExprContext _prevctx = _localctx;
|
|
int _startState = 30;
|
|
enterRecursionRule(_localctx, 30, RULE_addExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToMulContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(213);
|
|
mulExpr(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(223);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(221);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new AddExpContext(new AddExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_addExpr);
|
|
setState(215);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(216);
|
|
match(PLUS);
|
|
setState(217);
|
|
mulExpr(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new SubExpContext(new AddExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_addExpr);
|
|
setState(218);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(219);
|
|
match(MINUS);
|
|
setState(220);
|
|
mulExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(225);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,16,_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 MulExprContext extends ParserRuleContext {
|
|
public MulExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_mulExpr; }
|
|
|
|
public MulExprContext() { }
|
|
public void copyFrom(MulExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToShiftContext extends MulExprContext {
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public ToShiftContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToShift(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToShift(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToShift(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MulExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode MULT() { return getToken(MathExprParser.MULT, 0); }
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public MulExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMulExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMulExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMulExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ModExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode MOD() { return getToken(MathExprParser.MOD, 0); }
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public ModExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterModExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitModExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitModExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DivExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode DIV() { return getToken(MathExprParser.DIV, 0); }
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public DivExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterDivExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitDivExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitDivExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MulExprContext mulExpr() throws RecognitionException {
|
|
return mulExpr(0);
|
|
}
|
|
|
|
private MulExprContext mulExpr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
MulExprContext _localctx = new MulExprContext(_ctx, _parentState);
|
|
MulExprContext _prevctx = _localctx;
|
|
int _startState = 32;
|
|
enterRecursionRule(_localctx, 32, RULE_mulExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToShiftContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(227);
|
|
shiftExpr(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(240);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(238);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new MulExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(229);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(230);
|
|
match(MULT);
|
|
setState(231);
|
|
shiftExpr(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new DivExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(232);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(233);
|
|
match(DIV);
|
|
setState(234);
|
|
shiftExpr(0);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new ModExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(235);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(236);
|
|
match(MOD);
|
|
setState(237);
|
|
shiftExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(242);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,18,_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 ShiftExprContext extends ParserRuleContext {
|
|
public ShiftExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_shiftExpr; }
|
|
|
|
public ShiftExprContext() { }
|
|
public void copyFrom(ShiftExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RShiftExpContext extends ShiftExprContext {
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public TerminalNode RSHIFT() { return getToken(MathExprParser.RSHIFT, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public RShiftExpContext(ShiftExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRShiftExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRShiftExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRShiftExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LShiftExpContext extends ShiftExprContext {
|
|
public ShiftExprContext shiftExpr() {
|
|
return getRuleContext(ShiftExprContext.class,0);
|
|
}
|
|
public TerminalNode LSHIFT() { return getToken(MathExprParser.LSHIFT, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public LShiftExpContext(ShiftExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLShiftExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLShiftExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLShiftExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToPowContext extends ShiftExprContext {
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public ToPowContext(ShiftExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToPow(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToPow(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToPow(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ShiftExprContext shiftExpr() throws RecognitionException {
|
|
return shiftExpr(0);
|
|
}
|
|
|
|
private ShiftExprContext shiftExpr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ShiftExprContext _localctx = new ShiftExprContext(_ctx, _parentState);
|
|
ShiftExprContext _prevctx = _localctx;
|
|
int _startState = 34;
|
|
enterRecursionRule(_localctx, 34, RULE_shiftExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToPowContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(244);
|
|
powExpr();
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(254);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(252);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new LShiftExpContext(new ShiftExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpr);
|
|
setState(246);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(247);
|
|
match(LSHIFT);
|
|
setState(248);
|
|
powExpr();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new RShiftExpContext(new ShiftExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpr);
|
|
setState(249);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(250);
|
|
match(RSHIFT);
|
|
setState(251);
|
|
powExpr();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(256);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,20,_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 PowExprContext extends ParserRuleContext {
|
|
public PowExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_powExpr; }
|
|
|
|
public PowExprContext() { }
|
|
public void copyFrom(PowExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PowExpContext extends PowExprContext {
|
|
public UnaryExprContext unaryExpr() {
|
|
return getRuleContext(UnaryExprContext.class,0);
|
|
}
|
|
public TerminalNode POW() { return getToken(MathExprParser.POW, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public PowExpContext(PowExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPowExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPowExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPowExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToUnaryContext extends PowExprContext {
|
|
public UnaryExprContext unaryExpr() {
|
|
return getRuleContext(UnaryExprContext.class,0);
|
|
}
|
|
public ToUnaryContext(PowExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToUnary(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToUnary(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToUnary(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PowExprContext powExpr() throws RecognitionException {
|
|
PowExprContext _localctx = new PowExprContext(_ctx, getState());
|
|
enterRule(_localctx, 36, RULE_powExpr);
|
|
try {
|
|
setState(262);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
|
|
case 1:
|
|
_localctx = new PowExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(257);
|
|
unaryExpr();
|
|
setState(258);
|
|
match(POW);
|
|
setState(259);
|
|
powExpr();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new ToUnaryContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(261);
|
|
unaryExpr();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnaryExprContext extends ParserRuleContext {
|
|
public UnaryExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unaryExpr; }
|
|
|
|
public UnaryExprContext() { }
|
|
public void copyFrom(UnaryExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnaryPlusContext extends UnaryExprContext {
|
|
public TerminalNode PLUS() { return getToken(MathExprParser.PLUS, 0); }
|
|
public UnaryExprContext unaryExpr() {
|
|
return getRuleContext(UnaryExprContext.class,0);
|
|
}
|
|
public UnaryPlusContext(UnaryExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterUnaryPlus(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitUnaryPlus(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitUnaryPlus(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnaryMinusContext extends UnaryExprContext {
|
|
public TerminalNode MINUS() { return getToken(MathExprParser.MINUS, 0); }
|
|
public UnaryExprContext unaryExpr() {
|
|
return getRuleContext(UnaryExprContext.class,0);
|
|
}
|
|
public UnaryMinusContext(UnaryExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterUnaryMinus(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitUnaryMinus(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitUnaryMinus(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToIndexContext extends UnaryExprContext {
|
|
public IndexExprContext indexExpr() {
|
|
return getRuleContext(IndexExprContext.class,0);
|
|
}
|
|
public ToIndexContext(UnaryExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToIndex(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToIndex(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToIndex(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final UnaryExprContext unaryExpr() throws RecognitionException {
|
|
UnaryExprContext _localctx = new UnaryExprContext(_ctx, getState());
|
|
enterRule(_localctx, 38, RULE_unaryExpr);
|
|
try {
|
|
setState(269);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case PLUS:
|
|
_localctx = new UnaryPlusContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(264);
|
|
match(PLUS);
|
|
setState(265);
|
|
unaryExpr();
|
|
}
|
|
break;
|
|
case MINUS:
|
|
_localctx = new UnaryMinusContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(266);
|
|
match(MINUS);
|
|
setState(267);
|
|
unaryExpr();
|
|
}
|
|
break;
|
|
case SIN:
|
|
case COS:
|
|
case TAN:
|
|
case ASIN:
|
|
case ACOS:
|
|
case ATAN:
|
|
case ATAN2:
|
|
case SINH:
|
|
case COSH:
|
|
case TANH:
|
|
case ASINH:
|
|
case ACOSH:
|
|
case ATANH:
|
|
case ABS:
|
|
case SQRT:
|
|
case LN:
|
|
case LOG:
|
|
case EXP:
|
|
case SMIN:
|
|
case SMAX:
|
|
case TMIN:
|
|
case TMAX:
|
|
case TNORM:
|
|
case SNORM:
|
|
case FLOOR:
|
|
case CEIL:
|
|
case ROUND:
|
|
case GAMMA:
|
|
case POWE:
|
|
case SIGM:
|
|
case CLAMP:
|
|
case SFFT:
|
|
case SIFFT:
|
|
case ANGL:
|
|
case PRNT:
|
|
case PRINT_SHAPE:
|
|
case NVL:
|
|
case LERP:
|
|
case STEP:
|
|
case SMOOTHSTEP:
|
|
case FRACT:
|
|
case RELU:
|
|
case SOFTPLUS:
|
|
case GELU:
|
|
case SIGN:
|
|
case MAP:
|
|
case EZCONV:
|
|
case CONV:
|
|
case SWAP:
|
|
case PERM:
|
|
case RESHAPE:
|
|
case RANGE:
|
|
case LINSPACE:
|
|
case LOGSPACE:
|
|
case TOPK:
|
|
case BOTK:
|
|
case PINV:
|
|
case SUM:
|
|
case MEAN:
|
|
case STD:
|
|
case VAR:
|
|
case QUARTILE:
|
|
case PERCENTILE:
|
|
case QUANTILE:
|
|
case DOT:
|
|
case MOMENT:
|
|
case ERF:
|
|
case ERFINV:
|
|
case ANY:
|
|
case ALL:
|
|
case EDGE:
|
|
case GAUSSIAN:
|
|
case MEDIAN:
|
|
case MODE:
|
|
case CUMSUM:
|
|
case CUMPROD:
|
|
case TOPK_IND:
|
|
case BOTK_IND:
|
|
case CUBIC_EASE:
|
|
case ELASTIC_EASE:
|
|
case SINE_EASE:
|
|
case SMOOTHERSTEP:
|
|
case DIST:
|
|
case REMAP:
|
|
case COSSIM:
|
|
case COUNT:
|
|
case FLATTEN:
|
|
case APPEND:
|
|
case GET_VALUE:
|
|
case FLOW_APPLY:
|
|
case BATCH_SHUFFLE:
|
|
case MOTION_MASK:
|
|
case FLOW_TO_IMAGE:
|
|
case FLOW_MAG:
|
|
case FLOW_ANG:
|
|
case WHERE:
|
|
case HISTOGRAM:
|
|
case OVERLAY:
|
|
case PAD:
|
|
case CROSS:
|
|
case MATMUL:
|
|
case RIFE:
|
|
case BNOT:
|
|
case BITCOUNT:
|
|
case SHAPE:
|
|
case BAND:
|
|
case XOR:
|
|
case BOR:
|
|
case TENSOR:
|
|
case PUSH:
|
|
case POP:
|
|
case CLEAR:
|
|
case HAS:
|
|
case GET:
|
|
case CONCAT:
|
|
case INT:
|
|
case FLOAT:
|
|
case UPPER:
|
|
case LOWER:
|
|
case TRIM:
|
|
case SPLIT:
|
|
case JOIN:
|
|
case SUBSTRING:
|
|
case SUBSTR:
|
|
case FIND:
|
|
case REPLACE:
|
|
case DILATE:
|
|
case ERODE:
|
|
case MORPH_OPEN:
|
|
case MORPH_CLOSE:
|
|
case RGB_TO_OKLAB:
|
|
case RGB_TO_CILAB:
|
|
case OKLAB_TO_RGB:
|
|
case CILAB_TO_RGB:
|
|
case RGB_TO_HSV:
|
|
case HSV_TO_RGB:
|
|
case INT_TO_RGB:
|
|
case RGB_TO_INT:
|
|
case INTERPOLATE_LINEAR:
|
|
case INTERPOLATE_AREA:
|
|
case INTERPOLATE_NEAREST:
|
|
case BREAK:
|
|
case CONTINUE:
|
|
case TIMESTAMP:
|
|
case SORT:
|
|
case ARGSORT:
|
|
case ARGMIN:
|
|
case ARGMAX:
|
|
case SOFTMAX:
|
|
case SOFTMIN:
|
|
case UNIQUE:
|
|
case FLIP:
|
|
case ROLL:
|
|
case COV:
|
|
case CORR:
|
|
case ENTROPY:
|
|
case CROP:
|
|
case NONE:
|
|
case NOISE:
|
|
case RAND:
|
|
case CAUCHY:
|
|
case EXPONENTIAL:
|
|
case LOGNORMAL:
|
|
case BERNOULLI:
|
|
case POISSON:
|
|
case GAMMADIST:
|
|
case BETADIST:
|
|
case LAPLACEDIST:
|
|
case GUMBELDIST:
|
|
case WEIBULLDIST:
|
|
case CHI2DIST:
|
|
case STUDENTTDIST:
|
|
case PERLIN:
|
|
case CELLULAR:
|
|
case PLASMA:
|
|
case PIPE:
|
|
case LPAREN:
|
|
case LBRACKET:
|
|
case NUMBER:
|
|
case CONSTANT:
|
|
case STRING:
|
|
case VARIABLE:
|
|
_localctx = new ToIndexContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(268);
|
|
indexExpr(0);
|
|
}
|
|
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 IndexExprContext extends ParserRuleContext {
|
|
public IndexExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_indexExpr; }
|
|
|
|
public IndexExprContext() { }
|
|
public void copyFrom(IndexExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IndexExpContext extends IndexExprContext {
|
|
public IndexExprContext indexExpr() {
|
|
return getRuleContext(IndexExprContext.class,0);
|
|
}
|
|
public TerminalNode LBRACKET() { return getToken(MathExprParser.LBRACKET, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RBRACKET() { return getToken(MathExprParser.RBRACKET, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public IndexExpContext(IndexExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterIndexExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitIndexExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitIndexExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ToAtomContext extends IndexExprContext {
|
|
public AtomContext atom() {
|
|
return getRuleContext(AtomContext.class,0);
|
|
}
|
|
public ToAtomContext(IndexExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterToAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitToAtom(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitToAtom(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final IndexExprContext indexExpr() throws RecognitionException {
|
|
return indexExpr(0);
|
|
}
|
|
|
|
private IndexExprContext indexExpr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
IndexExprContext _localctx = new IndexExprContext(_ctx, _parentState);
|
|
IndexExprContext _prevctx = _localctx;
|
|
int _startState = 40;
|
|
enterRecursionRule(_localctx, 40, RULE_indexExpr, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToAtomContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(272);
|
|
atom();
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(288);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,24,_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 IndexExpContext(new IndexExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_indexExpr);
|
|
setState(274);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(275);
|
|
match(LBRACKET);
|
|
setState(276);
|
|
expr();
|
|
setState(281);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(277);
|
|
match(COMMA);
|
|
setState(278);
|
|
expr();
|
|
}
|
|
}
|
|
setState(283);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(284);
|
|
match(RBRACKET);
|
|
}
|
|
}
|
|
}
|
|
setState(290);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,24,_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 AtomContext extends ParserRuleContext {
|
|
public AtomContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_atom; }
|
|
|
|
public AtomContext() { }
|
|
public void copyFrom(AtomContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func5ExpContext extends AtomContext {
|
|
public Func5Context func5() {
|
|
return getRuleContext(Func5Context.class,0);
|
|
}
|
|
public Func5ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc5Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc5Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc5Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func4ExpContext extends AtomContext {
|
|
public Func4Context func4() {
|
|
return getRuleContext(Func4Context.class,0);
|
|
}
|
|
public Func4ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc4Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc4Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc4Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func2ExpContext extends AtomContext {
|
|
public Func2Context func2() {
|
|
return getRuleContext(Func2Context.class,0);
|
|
}
|
|
public Func2ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc2Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc2Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc2Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func3ExpContext extends AtomContext {
|
|
public Func3Context func3() {
|
|
return getRuleContext(Func3Context.class,0);
|
|
}
|
|
public Func3ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc3Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc3Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc3Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StringExpContext extends AtomContext {
|
|
public TerminalNode STRING() { return getToken(MathExprParser.STRING, 0); }
|
|
public StringExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterStringExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitStringExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitStringExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstantExpContext extends AtomContext {
|
|
public TerminalNode CONSTANT() { return getToken(MathExprParser.CONSTANT, 0); }
|
|
public ConstantExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterConstantExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitConstantExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitConstantExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NoneExpContext extends AtomContext {
|
|
public TerminalNode NONE() { return getToken(MathExprParser.NONE, 0); }
|
|
public NoneExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterNoneExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitNoneExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitNoneExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BreakExpContext extends AtomContext {
|
|
public TerminalNode BREAK() { return getToken(MathExprParser.BREAK, 0); }
|
|
public BreakExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBreakExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBreakExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBreakExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FuncNExpContext extends AtomContext {
|
|
public FuncNContext funcN() {
|
|
return getRuleContext(FuncNContext.class,0);
|
|
}
|
|
public FuncNExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFuncNExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFuncNExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFuncNExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AbsExpContext extends AtomContext {
|
|
public List<TerminalNode> PIPE() { return getTokens(MathExprParser.PIPE); }
|
|
public TerminalNode PIPE(int i) {
|
|
return getToken(MathExprParser.PIPE, i);
|
|
}
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public AbsExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAbsExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAbsExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAbsExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ListExpContext extends AtomContext {
|
|
public TerminalNode LBRACKET() { return getToken(MathExprParser.LBRACKET, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RBRACKET() { return getToken(MathExprParser.RBRACKET, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public ListExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterListExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitListExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitListExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ContinueExpContext extends AtomContext {
|
|
public TerminalNode CONTINUE() { return getToken(MathExprParser.CONTINUE, 0); }
|
|
public ContinueExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterContinueExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitContinueExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitContinueExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableExpContext extends AtomContext {
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public VariableExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterVariableExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitVariableExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitVariableExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CallExpContext extends AtomContext {
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ExprListContext exprList() {
|
|
return getRuleContext(ExprListContext.class,0);
|
|
}
|
|
public CallExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCallExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCallExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCallExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ParenExpContext extends AtomContext {
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ParenExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterParenExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitParenExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitParenExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FuncNoiseExpContext extends AtomContext {
|
|
public FuncNoiseContext funcNoise() {
|
|
return getRuleContext(FuncNoiseContext.class,0);
|
|
}
|
|
public FuncNoiseExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFuncNoiseExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFuncNoiseExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFuncNoiseExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func1ExpContext extends AtomContext {
|
|
public Func1Context func1() {
|
|
return getRuleContext(Func1Context.class,0);
|
|
}
|
|
public Func1ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc1Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc1Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc1Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Func0ExpContext extends AtomContext {
|
|
public Func0Context func0() {
|
|
return getRuleContext(Func0Context.class,0);
|
|
}
|
|
public Func0ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFunc0Exp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFunc0Exp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFunc0Exp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NumberExpContext extends AtomContext {
|
|
public TerminalNode NUMBER() { return getToken(MathExprParser.NUMBER, 0); }
|
|
public NumberExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterNumberExp(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitNumberExp(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitNumberExp(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AtomContext atom() throws RecognitionException {
|
|
AtomContext _localctx = new AtomContext(_ctx, getState());
|
|
enterRule(_localctx, 42, RULE_atom);
|
|
int _la;
|
|
try {
|
|
setState(331);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
|
|
case 1:
|
|
_localctx = new Func0ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(291);
|
|
func0();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new Func1ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(292);
|
|
func1();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new Func2ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(293);
|
|
func2();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new Func3ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(294);
|
|
func3();
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new Func4ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(295);
|
|
func4();
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new Func5ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(296);
|
|
func5();
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new FuncNExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(297);
|
|
funcN();
|
|
}
|
|
break;
|
|
case 8:
|
|
_localctx = new FuncNoiseExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(298);
|
|
funcNoise();
|
|
}
|
|
break;
|
|
case 9:
|
|
_localctx = new VariableExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(299);
|
|
match(VARIABLE);
|
|
}
|
|
break;
|
|
case 10:
|
|
_localctx = new NumberExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(300);
|
|
match(NUMBER);
|
|
}
|
|
break;
|
|
case 11:
|
|
_localctx = new ConstantExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(301);
|
|
match(CONSTANT);
|
|
}
|
|
break;
|
|
case 12:
|
|
_localctx = new StringExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(302);
|
|
match(STRING);
|
|
}
|
|
break;
|
|
case 13:
|
|
_localctx = new ParenExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(303);
|
|
match(LPAREN);
|
|
setState(304);
|
|
expr();
|
|
setState(305);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 14:
|
|
_localctx = new AbsExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(307);
|
|
match(PIPE);
|
|
setState(308);
|
|
expr();
|
|
setState(309);
|
|
match(PIPE);
|
|
}
|
|
break;
|
|
case 15:
|
|
_localctx = new ListExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(311);
|
|
match(LBRACKET);
|
|
setState(312);
|
|
expr();
|
|
setState(317);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(313);
|
|
match(COMMA);
|
|
setState(314);
|
|
expr();
|
|
}
|
|
}
|
|
setState(319);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(320);
|
|
match(RBRACKET);
|
|
}
|
|
break;
|
|
case 16:
|
|
_localctx = new CallExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(322);
|
|
match(VARIABLE);
|
|
setState(323);
|
|
match(LPAREN);
|
|
setState(325);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 72057594035322879L) != 0) || ((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & 61507L) != 0)) {
|
|
{
|
|
setState(324);
|
|
exprList();
|
|
}
|
|
}
|
|
|
|
setState(327);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 17:
|
|
_localctx = new NoneExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(328);
|
|
match(NONE);
|
|
}
|
|
break;
|
|
case 18:
|
|
_localctx = new BreakExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(329);
|
|
match(BREAK);
|
|
}
|
|
break;
|
|
case 19:
|
|
_localctx = new ContinueExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 19);
|
|
{
|
|
setState(330);
|
|
match(CONTINUE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExprListContext extends ParserRuleContext {
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public ExprListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_exprList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterExprList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitExprList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitExprList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExprListContext exprList() throws RecognitionException {
|
|
ExprListContext _localctx = new ExprListContext(_ctx, getState());
|
|
enterRule(_localctx, 44, RULE_exprList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(333);
|
|
expr();
|
|
setState(338);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(334);
|
|
match(COMMA);
|
|
setState(335);
|
|
expr();
|
|
}
|
|
}
|
|
setState(340);
|
|
_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 Func0Context extends ParserRuleContext {
|
|
public Func0Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func0; }
|
|
|
|
public Func0Context() { }
|
|
public void copyFrom(Func0Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TimestampFuncContext extends Func0Context {
|
|
public TerminalNode TIMESTAMP() { return getToken(MathExprParser.TIMESTAMP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TimestampFuncContext(Func0Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTimestampFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTimestampFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTimestampFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func0Context func0() throws RecognitionException {
|
|
Func0Context _localctx = new Func0Context(_ctx, getState());
|
|
enterRule(_localctx, 46, RULE_func0);
|
|
try {
|
|
_localctx = new TimestampFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(341);
|
|
match(TIMESTAMP);
|
|
setState(342);
|
|
match(LPAREN);
|
|
setState(343);
|
|
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 Func1Context extends ParserRuleContext {
|
|
public Func1Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func1; }
|
|
|
|
public Func1Context() { }
|
|
public void copyFrom(Func1Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SoftplusFuncContext extends Func1Context {
|
|
public TerminalNode SOFTPLUS() { return getToken(MathExprParser.SOFTPLUS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SoftplusFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSoftplusFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSoftplusFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSoftplusFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SoftminFuncContext extends Func1Context {
|
|
public TerminalNode SOFTMIN() { return getToken(MathExprParser.SOFTMIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public SoftminFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSoftminFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSoftminFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSoftminFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AcoshFuncContext extends Func1Context {
|
|
public TerminalNode ACOSH() { return getToken(MathExprParser.ACOSH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AcoshFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAcoshFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAcoshFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAcoshFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SqrtFuncContext extends Func1Context {
|
|
public TerminalNode SQRT() { return getToken(MathExprParser.SQRT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SqrtFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSqrtFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSqrtFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSqrtFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FloorFuncContext extends Func1Context {
|
|
public TerminalNode FLOOR() { return getToken(MathExprParser.FLOOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FloorFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFloorFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFloorFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFloorFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MeanFuncContext extends Func1Context {
|
|
public TerminalNode MEAN() { return getToken(MathExprParser.MEAN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public MeanFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMeanFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMeanFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMeanFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CeilFuncContext extends Func1Context {
|
|
public TerminalNode CEIL() { return getToken(MathExprParser.CEIL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CeilFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCeilFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCeilFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCeilFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MotionMaskFuncContext extends Func1Context {
|
|
public TerminalNode MOTION_MASK() { return getToken(MathExprParser.MOTION_MASK, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public MotionMaskFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMotionMaskFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMotionMaskFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMotionMaskFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EntropyFuncContext extends Func1Context {
|
|
public TerminalNode ENTROPY() { return getToken(MathExprParser.ENTROPY, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public EntropyFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterEntropyFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitEntropyFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitEntropyFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AbsFuncContext extends Func1Context {
|
|
public TerminalNode ABS() { return getToken(MathExprParser.ABS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AbsFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAbsFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAbsFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAbsFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AtanFuncContext extends Func1Context {
|
|
public TerminalNode ATAN() { return getToken(MathExprParser.ATAN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AtanFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAtanFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAtanFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAtanFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TrimFuncContext extends Func1Context {
|
|
public TerminalNode TRIM() { return getToken(MathExprParser.TRIM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TrimFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTrimFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTrimFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTrimFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SinhFuncContext extends Func1Context {
|
|
public TerminalNode SINH() { return getToken(MathExprParser.SINH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SinhFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSinhFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSinhFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSinhFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SigmoidFuncContext extends Func1Context {
|
|
public TerminalNode SIGM() { return getToken(MathExprParser.SIGM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SigmoidFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSigmoidFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSigmoidFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSigmoidFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitNotFuncContext extends Func1Context {
|
|
public TerminalNode BNOT() { return getToken(MathExprParser.BNOT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BitNotFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBitNotFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBitNotFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBitNotFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LogFuncContext extends Func1Context {
|
|
public TerminalNode LOG() { return getToken(MathExprParser.LOG, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LogFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLogFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLogFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLogFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TNormFuncContext extends Func1Context {
|
|
public TerminalNode TNORM() { return getToken(MathExprParser.TNORM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TNormFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTNormFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTNormFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTNormFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SinFuncContext extends Func1Context {
|
|
public TerminalNode SIN() { return getToken(MathExprParser.SIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SinFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlattenFuncContext extends Func1Context {
|
|
public TerminalNode FLATTEN() { return getToken(MathExprParser.FLATTEN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlattenFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlattenFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlattenFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlattenFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AcosFuncContext extends Func1Context {
|
|
public TerminalNode ACOS() { return getToken(MathExprParser.ACOS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AcosFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAcosFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAcosFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAcosFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CoshFuncContext extends Func1Context {
|
|
public TerminalNode COSH() { return getToken(MathExprParser.COSH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CoshFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCoshFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCoshFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCoshFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnglFuncContext extends Func1Context {
|
|
public TerminalNode ANGL() { return getToken(MathExprParser.ANGL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AnglFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAnglFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAnglFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAnglFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CumsumFuncContext extends Func1Context {
|
|
public TerminalNode CUMSUM() { return getToken(MathExprParser.CUMSUM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CumsumFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCumsumFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCumsumFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCumsumFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GetFuncContext extends Func1Context {
|
|
public TerminalNode GET() { return getToken(MathExprParser.GET, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GetFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGetFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGetFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGetFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SignFuncContext extends Func1Context {
|
|
public TerminalNode SIGN() { return getToken(MathExprParser.SIGN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SignFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSignFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSignFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSignFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TanFuncContext extends Func1Context {
|
|
public TerminalNode TAN() { return getToken(MathExprParser.TAN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TanFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTanFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTanFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTanFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PinvFuncContext extends Func1Context {
|
|
public TerminalNode PINV() { return getToken(MathExprParser.PINV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PinvFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPinvFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPinvFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPinvFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FractFuncContext extends Func1Context {
|
|
public TerminalNode FRACT() { return getToken(MathExprParser.FRACT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FractFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFractFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFractFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFractFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GammaFuncContext extends Func1Context {
|
|
public TerminalNode GAMMA() { return getToken(MathExprParser.GAMMA, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GammaFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGammaFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGammaFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGammaFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SoftmaxFuncContext extends Func1Context {
|
|
public TerminalNode SOFTMAX() { return getToken(MathExprParser.SOFTMAX, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public SoftmaxFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSoftmaxFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSoftmaxFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSoftmaxFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SfftFuncContext extends Func1Context {
|
|
public TerminalNode SFFT() { return getToken(MathExprParser.SFFT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SfftFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSfftFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSfftFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSfftFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VarFuncContext extends Func1Context {
|
|
public TerminalNode VAR() { return getToken(MathExprParser.VAR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public VarFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterVarFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitVarFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitVarFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AsinFuncContext extends Func1Context {
|
|
public TerminalNode ASIN() { return getToken(MathExprParser.ASIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AsinFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAsinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAsinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAsinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CountFuncContext extends Func1Context {
|
|
public TerminalNode COUNT() { return getToken(MathExprParser.COUNT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CountFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCountFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCountFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCountFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AsinhFuncContext extends Func1Context {
|
|
public TerminalNode ASINH() { return getToken(MathExprParser.ASINH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AsinhFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAsinhFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAsinhFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAsinhFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FloatFuncContext extends Func1Context {
|
|
public TerminalNode FLOAT() { return getToken(MathExprParser.FLOAT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FloatFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFloatFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFloatFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFloatFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AllFuncContext extends Func1Context {
|
|
public TerminalNode ALL() { return getToken(MathExprParser.ALL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AllFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAllFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAllFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAllFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AtanhFuncContext extends Func1Context {
|
|
public TerminalNode ATANH() { return getToken(MathExprParser.ATANH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AtanhFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAtanhFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAtanhFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAtanhFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClearFuncContext extends Func1Context {
|
|
public TerminalNode CLEAR() { return getToken(MathExprParser.CLEAR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ClearFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterClearFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitClearFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitClearFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ErfinvFuncContext extends Func1Context {
|
|
public TerminalNode ERFINV() { return getToken(MathExprParser.ERFINV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ErfinvFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterErfinvFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitErfinvFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitErfinvFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlowToImageFuncContext extends Func1Context {
|
|
public TerminalNode FLOW_TO_IMAGE() { return getToken(MathExprParser.FLOW_TO_IMAGE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlowToImageFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlowToImageFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlowToImageFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlowToImageFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PopFuncContext extends Func1Context {
|
|
public TerminalNode POP() { return getToken(MathExprParser.POP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PopFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPopFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPopFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPopFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MedianFuncContext extends Func1Context {
|
|
public TerminalNode MEDIAN() { return getToken(MathExprParser.MEDIAN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public MedianFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMedianFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMedianFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMedianFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrintShapeFuncContext extends Func1Context {
|
|
public TerminalNode PRINT_SHAPE() { return getToken(MathExprParser.PRINT_SHAPE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PrintShapeFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPrintShapeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPrintShapeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPrintShapeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SortFuncContext extends Func1Context {
|
|
public TerminalNode SORT() { return getToken(MathExprParser.SORT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SortFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSortFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSortFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSortFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MorphOpenFuncContext extends Func1Context {
|
|
public TerminalNode MORPH_OPEN() { return getToken(MathExprParser.MORPH_OPEN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public MorphOpenFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMorphOpenFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMorphOpenFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMorphOpenFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlowAngFuncContext extends Func1Context {
|
|
public TerminalNode FLOW_ANG() { return getToken(MathExprParser.FLOW_ANG, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlowAngFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlowAngFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlowAngFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlowAngFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TanhFuncContext extends Func1Context {
|
|
public TerminalNode TANH() { return getToken(MathExprParser.TANH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TanhFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTanhFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTanhFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTanhFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnyFuncContext extends Func1Context {
|
|
public TerminalNode ANY() { return getToken(MathExprParser.ANY, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AnyFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAnyFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAnyFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAnyFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ModeFuncContext extends Func1Context {
|
|
public TerminalNode MODE() { return getToken(MathExprParser.MODE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ModeFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterModeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitModeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitModeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ErodeFuncContext extends Func1Context {
|
|
public TerminalNode ERODE() { return getToken(MathExprParser.ERODE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public ErodeFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterErodeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitErodeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitErodeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ErfFuncContext extends Func1Context {
|
|
public TerminalNode ERF() { return getToken(MathExprParser.ERF, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ErfFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterErfFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitErfFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitErfFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UniqueFuncContext extends Func1Context {
|
|
public TerminalNode UNIQUE() { return getToken(MathExprParser.UNIQUE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public UniqueFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterUniqueFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitUniqueFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitUniqueFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RoundFuncContext extends Func1Context {
|
|
public TerminalNode ROUND() { return getToken(MathExprParser.ROUND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public RoundFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRoundFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRoundFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRoundFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GeluFuncContext extends Func1Context {
|
|
public TerminalNode GELU() { return getToken(MathExprParser.GELU, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GeluFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGeluFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGeluFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGeluFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrintFuncContext extends Func1Context {
|
|
public TerminalNode PRNT() { return getToken(MathExprParser.PRNT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PrintFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPrintFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPrintFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPrintFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArgmaxFuncContext extends Func1Context {
|
|
public TerminalNode ARGMAX() { return getToken(MathExprParser.ARGMAX, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ArgmaxFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterArgmaxFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitArgmaxFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitArgmaxFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UpperFuncContext extends Func1Context {
|
|
public TerminalNode UPPER() { return getToken(MathExprParser.UPPER, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public UpperFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterUpperFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitUpperFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitUpperFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReluFuncContext extends Func1Context {
|
|
public TerminalNode RELU() { return getToken(MathExprParser.RELU, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ReluFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterReluFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitReluFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitReluFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ShapeFuncContext extends Func1Context {
|
|
public TerminalNode SHAPE() { return getToken(MathExprParser.SHAPE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ShapeFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterShapeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitShapeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitShapeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IntFuncContext extends Func1Context {
|
|
public TerminalNode INT() { return getToken(MathExprParser.INT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public IntFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterIntFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitIntFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitIntFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EdgeFuncContext extends Func1Context {
|
|
public TerminalNode EDGE() { return getToken(MathExprParser.EDGE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public EdgeFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterEdgeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitEdgeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitEdgeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LnFuncContext extends Func1Context {
|
|
public TerminalNode LN() { return getToken(MathExprParser.LN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LnFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLnFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLnFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLnFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitCountFuncContext extends Func1Context {
|
|
public TerminalNode BITCOUNT() { return getToken(MathExprParser.BITCOUNT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BitCountFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBitCountFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBitCountFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBitCountFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SNormFuncContext extends Func1Context {
|
|
public TerminalNode SNORM() { return getToken(MathExprParser.SNORM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SNormFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSNormFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSNormFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSNormFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArgminFuncContext extends Func1Context {
|
|
public TerminalNode ARGMIN() { return getToken(MathExprParser.ARGMIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ArgminFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterArgminFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitArgminFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitArgminFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StdFuncContext extends Func1Context {
|
|
public TerminalNode STD() { return getToken(MathExprParser.STD, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public StdFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterStdFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitStdFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitStdFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DilateFuncContext extends Func1Context {
|
|
public TerminalNode DILATE() { return getToken(MathExprParser.DILATE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public DilateFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterDilateFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitDilateFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitDilateFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SumFuncContext extends Func1Context {
|
|
public TerminalNode SUM() { return getToken(MathExprParser.SUM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SumFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSumFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSumFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSumFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class HasFuncContext extends Func1Context {
|
|
public TerminalNode HAS() { return getToken(MathExprParser.HAS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public HasFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterHasFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitHasFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitHasFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlowMagFuncContext extends Func1Context {
|
|
public TerminalNode FLOW_MAG() { return getToken(MathExprParser.FLOW_MAG, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlowMagFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlowMagFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlowMagFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlowMagFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CosFuncContext extends Func1Context {
|
|
public TerminalNode COS() { return getToken(MathExprParser.COS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CosFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCosFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCosFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCosFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArgsortFuncContext extends Func1Context {
|
|
public TerminalNode ARGSORT() { return getToken(MathExprParser.ARGSORT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public ArgsortFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterArgsortFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitArgsortFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitArgsortFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CumprodFuncContext extends Func1Context {
|
|
public TerminalNode CUMPROD() { return getToken(MathExprParser.CUMPROD, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CumprodFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCumprodFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCumprodFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCumprodFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MorphCloseFuncContext extends Func1Context {
|
|
public TerminalNode MORPH_CLOSE() { return getToken(MathExprParser.MORPH_CLOSE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public MorphCloseFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMorphCloseFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMorphCloseFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMorphCloseFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExpFuncContext extends Func1Context {
|
|
public TerminalNode EXP() { return getToken(MathExprParser.EXP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ExpFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterExpFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitExpFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitExpFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LowerFuncContext extends Func1Context {
|
|
public TerminalNode LOWER() { return getToken(MathExprParser.LOWER, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LowerFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLowerFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLowerFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLowerFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func1Context func1() throws RecognitionException {
|
|
Func1Context _localctx = new Func1Context(_ctx, getState());
|
|
enterRule(_localctx, 48, RULE_func1);
|
|
int _la;
|
|
try {
|
|
setState(762);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SIN:
|
|
_localctx = new SinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(345);
|
|
match(SIN);
|
|
setState(346);
|
|
match(LPAREN);
|
|
setState(347);
|
|
expr();
|
|
setState(348);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COS:
|
|
_localctx = new CosFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(350);
|
|
match(COS);
|
|
setState(351);
|
|
match(LPAREN);
|
|
setState(352);
|
|
expr();
|
|
setState(353);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TAN:
|
|
_localctx = new TanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(355);
|
|
match(TAN);
|
|
setState(356);
|
|
match(LPAREN);
|
|
setState(357);
|
|
expr();
|
|
setState(358);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ASIN:
|
|
_localctx = new AsinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(360);
|
|
match(ASIN);
|
|
setState(361);
|
|
match(LPAREN);
|
|
setState(362);
|
|
expr();
|
|
setState(363);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ACOS:
|
|
_localctx = new AcosFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(365);
|
|
match(ACOS);
|
|
setState(366);
|
|
match(LPAREN);
|
|
setState(367);
|
|
expr();
|
|
setState(368);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ATAN:
|
|
_localctx = new AtanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(370);
|
|
match(ATAN);
|
|
setState(371);
|
|
match(LPAREN);
|
|
setState(372);
|
|
expr();
|
|
setState(373);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SINH:
|
|
_localctx = new SinhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(375);
|
|
match(SINH);
|
|
setState(376);
|
|
match(LPAREN);
|
|
setState(377);
|
|
expr();
|
|
setState(378);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COSH:
|
|
_localctx = new CoshFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(380);
|
|
match(COSH);
|
|
setState(381);
|
|
match(LPAREN);
|
|
setState(382);
|
|
expr();
|
|
setState(383);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TANH:
|
|
_localctx = new TanhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(385);
|
|
match(TANH);
|
|
setState(386);
|
|
match(LPAREN);
|
|
setState(387);
|
|
expr();
|
|
setState(388);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ASINH:
|
|
_localctx = new AsinhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(390);
|
|
match(ASINH);
|
|
setState(391);
|
|
match(LPAREN);
|
|
setState(392);
|
|
expr();
|
|
setState(393);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ACOSH:
|
|
_localctx = new AcoshFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(395);
|
|
match(ACOSH);
|
|
setState(396);
|
|
match(LPAREN);
|
|
setState(397);
|
|
expr();
|
|
setState(398);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ATANH:
|
|
_localctx = new AtanhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(400);
|
|
match(ATANH);
|
|
setState(401);
|
|
match(LPAREN);
|
|
setState(402);
|
|
expr();
|
|
setState(403);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ABS:
|
|
_localctx = new AbsFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(405);
|
|
match(ABS);
|
|
setState(406);
|
|
match(LPAREN);
|
|
setState(407);
|
|
expr();
|
|
setState(408);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SQRT:
|
|
_localctx = new SqrtFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(410);
|
|
match(SQRT);
|
|
setState(411);
|
|
match(LPAREN);
|
|
setState(412);
|
|
expr();
|
|
setState(413);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LN:
|
|
_localctx = new LnFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(415);
|
|
match(LN);
|
|
setState(416);
|
|
match(LPAREN);
|
|
setState(417);
|
|
expr();
|
|
setState(418);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LOG:
|
|
_localctx = new LogFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(420);
|
|
match(LOG);
|
|
setState(421);
|
|
match(LPAREN);
|
|
setState(422);
|
|
expr();
|
|
setState(423);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EXP:
|
|
_localctx = new ExpFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(425);
|
|
match(EXP);
|
|
setState(426);
|
|
match(LPAREN);
|
|
setState(427);
|
|
expr();
|
|
setState(428);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TNORM:
|
|
_localctx = new TNormFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(430);
|
|
match(TNORM);
|
|
setState(431);
|
|
match(LPAREN);
|
|
setState(432);
|
|
expr();
|
|
setState(433);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SNORM:
|
|
_localctx = new SNormFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 19);
|
|
{
|
|
setState(435);
|
|
match(SNORM);
|
|
setState(436);
|
|
match(LPAREN);
|
|
setState(437);
|
|
expr();
|
|
setState(438);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOOR:
|
|
_localctx = new FloorFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 20);
|
|
{
|
|
setState(440);
|
|
match(FLOOR);
|
|
setState(441);
|
|
match(LPAREN);
|
|
setState(442);
|
|
expr();
|
|
setState(443);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CEIL:
|
|
_localctx = new CeilFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 21);
|
|
{
|
|
setState(445);
|
|
match(CEIL);
|
|
setState(446);
|
|
match(LPAREN);
|
|
setState(447);
|
|
expr();
|
|
setState(448);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ROUND:
|
|
_localctx = new RoundFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 22);
|
|
{
|
|
setState(450);
|
|
match(ROUND);
|
|
setState(451);
|
|
match(LPAREN);
|
|
setState(452);
|
|
expr();
|
|
setState(453);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GAMMA:
|
|
_localctx = new GammaFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 23);
|
|
{
|
|
setState(455);
|
|
match(GAMMA);
|
|
setState(456);
|
|
match(LPAREN);
|
|
setState(457);
|
|
expr();
|
|
setState(458);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIGM:
|
|
_localctx = new SigmoidFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 24);
|
|
{
|
|
setState(460);
|
|
match(SIGM);
|
|
setState(461);
|
|
match(LPAREN);
|
|
setState(462);
|
|
expr();
|
|
setState(463);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ANGL:
|
|
_localctx = new AnglFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 25);
|
|
{
|
|
setState(465);
|
|
match(ANGL);
|
|
setState(466);
|
|
match(LPAREN);
|
|
setState(467);
|
|
expr();
|
|
setState(468);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PRNT:
|
|
_localctx = new PrintFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 26);
|
|
{
|
|
setState(470);
|
|
match(PRNT);
|
|
setState(471);
|
|
match(LPAREN);
|
|
setState(472);
|
|
expr();
|
|
setState(473);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FRACT:
|
|
_localctx = new FractFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 27);
|
|
{
|
|
setState(475);
|
|
match(FRACT);
|
|
setState(476);
|
|
match(LPAREN);
|
|
setState(477);
|
|
expr();
|
|
setState(478);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RELU:
|
|
_localctx = new ReluFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 28);
|
|
{
|
|
setState(480);
|
|
match(RELU);
|
|
setState(481);
|
|
match(LPAREN);
|
|
setState(482);
|
|
expr();
|
|
setState(483);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SOFTPLUS:
|
|
_localctx = new SoftplusFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 29);
|
|
{
|
|
setState(485);
|
|
match(SOFTPLUS);
|
|
setState(486);
|
|
match(LPAREN);
|
|
setState(487);
|
|
expr();
|
|
setState(488);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GELU:
|
|
_localctx = new GeluFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 30);
|
|
{
|
|
setState(490);
|
|
match(GELU);
|
|
setState(491);
|
|
match(LPAREN);
|
|
setState(492);
|
|
expr();
|
|
setState(493);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIGN:
|
|
_localctx = new SignFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 31);
|
|
{
|
|
setState(495);
|
|
match(SIGN);
|
|
setState(496);
|
|
match(LPAREN);
|
|
setState(497);
|
|
expr();
|
|
setState(498);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PRINT_SHAPE:
|
|
_localctx = new PrintShapeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 32);
|
|
{
|
|
setState(500);
|
|
match(PRINT_SHAPE);
|
|
setState(501);
|
|
match(LPAREN);
|
|
setState(502);
|
|
expr();
|
|
setState(503);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PINV:
|
|
_localctx = new PinvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 33);
|
|
{
|
|
setState(505);
|
|
match(PINV);
|
|
setState(506);
|
|
match(LPAREN);
|
|
setState(507);
|
|
expr();
|
|
setState(508);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SUM:
|
|
_localctx = new SumFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 34);
|
|
{
|
|
setState(510);
|
|
match(SUM);
|
|
setState(511);
|
|
match(LPAREN);
|
|
setState(512);
|
|
expr();
|
|
setState(513);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MEAN:
|
|
_localctx = new MeanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 35);
|
|
{
|
|
setState(515);
|
|
match(MEAN);
|
|
setState(516);
|
|
match(LPAREN);
|
|
setState(517);
|
|
expr();
|
|
setState(518);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case STD:
|
|
_localctx = new StdFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 36);
|
|
{
|
|
setState(520);
|
|
match(STD);
|
|
setState(521);
|
|
match(LPAREN);
|
|
setState(522);
|
|
expr();
|
|
setState(523);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case VAR:
|
|
_localctx = new VarFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 37);
|
|
{
|
|
setState(525);
|
|
match(VAR);
|
|
setState(526);
|
|
match(LPAREN);
|
|
setState(527);
|
|
expr();
|
|
setState(528);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SORT:
|
|
_localctx = new SortFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 38);
|
|
{
|
|
setState(530);
|
|
match(SORT);
|
|
setState(531);
|
|
match(LPAREN);
|
|
setState(532);
|
|
expr();
|
|
setState(533);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ANY:
|
|
_localctx = new AnyFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 39);
|
|
{
|
|
setState(535);
|
|
match(ANY);
|
|
setState(536);
|
|
match(LPAREN);
|
|
setState(537);
|
|
expr();
|
|
setState(538);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ALL:
|
|
_localctx = new AllFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 40);
|
|
{
|
|
setState(540);
|
|
match(ALL);
|
|
setState(541);
|
|
match(LPAREN);
|
|
setState(542);
|
|
expr();
|
|
setState(543);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EDGE:
|
|
_localctx = new EdgeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 41);
|
|
{
|
|
setState(545);
|
|
match(EDGE);
|
|
setState(546);
|
|
match(LPAREN);
|
|
setState(547);
|
|
expr();
|
|
setState(550);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(548);
|
|
match(COMMA);
|
|
setState(549);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(552);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MEDIAN:
|
|
_localctx = new MedianFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 42);
|
|
{
|
|
setState(554);
|
|
match(MEDIAN);
|
|
setState(555);
|
|
match(LPAREN);
|
|
setState(556);
|
|
expr();
|
|
setState(557);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MODE:
|
|
_localctx = new ModeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 43);
|
|
{
|
|
setState(559);
|
|
match(MODE);
|
|
setState(560);
|
|
match(LPAREN);
|
|
setState(561);
|
|
expr();
|
|
setState(562);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CUMSUM:
|
|
_localctx = new CumsumFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 44);
|
|
{
|
|
setState(564);
|
|
match(CUMSUM);
|
|
setState(565);
|
|
match(LPAREN);
|
|
setState(566);
|
|
expr();
|
|
setState(567);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COUNT:
|
|
_localctx = new CountFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 45);
|
|
{
|
|
setState(569);
|
|
match(COUNT);
|
|
setState(570);
|
|
match(LPAREN);
|
|
setState(571);
|
|
expr();
|
|
setState(572);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CUMPROD:
|
|
_localctx = new CumprodFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 46);
|
|
{
|
|
setState(574);
|
|
match(CUMPROD);
|
|
setState(575);
|
|
match(LPAREN);
|
|
setState(576);
|
|
expr();
|
|
setState(577);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case POP:
|
|
_localctx = new PopFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 47);
|
|
{
|
|
setState(579);
|
|
match(POP);
|
|
setState(580);
|
|
match(LPAREN);
|
|
setState(581);
|
|
expr();
|
|
setState(582);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CLEAR:
|
|
_localctx = new ClearFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 48);
|
|
{
|
|
setState(584);
|
|
match(CLEAR);
|
|
setState(585);
|
|
match(LPAREN);
|
|
setState(586);
|
|
expr();
|
|
setState(587);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case HAS:
|
|
_localctx = new HasFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 49);
|
|
{
|
|
setState(589);
|
|
match(HAS);
|
|
setState(590);
|
|
match(LPAREN);
|
|
setState(591);
|
|
expr();
|
|
setState(592);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GET:
|
|
_localctx = new GetFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 50);
|
|
{
|
|
setState(594);
|
|
match(GET);
|
|
setState(595);
|
|
match(LPAREN);
|
|
setState(596);
|
|
expr();
|
|
setState(597);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ARGSORT:
|
|
_localctx = new ArgsortFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 51);
|
|
{
|
|
setState(599);
|
|
match(ARGSORT);
|
|
setState(600);
|
|
match(LPAREN);
|
|
setState(601);
|
|
expr();
|
|
setState(604);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(602);
|
|
match(COMMA);
|
|
setState(603);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(606);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ARGMIN:
|
|
_localctx = new ArgminFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 52);
|
|
{
|
|
setState(608);
|
|
match(ARGMIN);
|
|
setState(609);
|
|
match(LPAREN);
|
|
setState(610);
|
|
expr();
|
|
setState(611);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ARGMAX:
|
|
_localctx = new ArgmaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 53);
|
|
{
|
|
setState(613);
|
|
match(ARGMAX);
|
|
setState(614);
|
|
match(LPAREN);
|
|
setState(615);
|
|
expr();
|
|
setState(616);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SOFTMAX:
|
|
_localctx = new SoftmaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 54);
|
|
{
|
|
setState(618);
|
|
match(SOFTMAX);
|
|
setState(619);
|
|
match(LPAREN);
|
|
setState(620);
|
|
expr();
|
|
setState(623);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(621);
|
|
match(COMMA);
|
|
setState(622);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(625);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SOFTMIN:
|
|
_localctx = new SoftminFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 55);
|
|
{
|
|
setState(627);
|
|
match(SOFTMIN);
|
|
setState(628);
|
|
match(LPAREN);
|
|
setState(629);
|
|
expr();
|
|
setState(632);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(630);
|
|
match(COMMA);
|
|
setState(631);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(634);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ERF:
|
|
_localctx = new ErfFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 56);
|
|
{
|
|
setState(636);
|
|
match(ERF);
|
|
setState(637);
|
|
match(LPAREN);
|
|
setState(638);
|
|
expr();
|
|
setState(639);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ERFINV:
|
|
_localctx = new ErfinvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 57);
|
|
{
|
|
setState(641);
|
|
match(ERFINV);
|
|
setState(642);
|
|
match(LPAREN);
|
|
setState(643);
|
|
expr();
|
|
setState(644);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case UNIQUE:
|
|
_localctx = new UniqueFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 58);
|
|
{
|
|
setState(646);
|
|
match(UNIQUE);
|
|
setState(647);
|
|
match(LPAREN);
|
|
setState(648);
|
|
expr();
|
|
setState(649);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLATTEN:
|
|
_localctx = new FlattenFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 59);
|
|
{
|
|
setState(651);
|
|
match(FLATTEN);
|
|
setState(652);
|
|
match(LPAREN);
|
|
setState(653);
|
|
expr();
|
|
setState(654);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MOTION_MASK:
|
|
_localctx = new MotionMaskFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 60);
|
|
{
|
|
setState(656);
|
|
match(MOTION_MASK);
|
|
setState(657);
|
|
match(LPAREN);
|
|
setState(658);
|
|
expr();
|
|
setState(659);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOW_TO_IMAGE:
|
|
_localctx = new FlowToImageFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 61);
|
|
{
|
|
setState(661);
|
|
match(FLOW_TO_IMAGE);
|
|
setState(662);
|
|
match(LPAREN);
|
|
setState(663);
|
|
expr();
|
|
setState(664);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BNOT:
|
|
_localctx = new BitNotFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 62);
|
|
{
|
|
setState(666);
|
|
match(BNOT);
|
|
setState(667);
|
|
match(LPAREN);
|
|
setState(668);
|
|
expr();
|
|
setState(669);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BITCOUNT:
|
|
_localctx = new BitCountFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 63);
|
|
{
|
|
setState(671);
|
|
match(BITCOUNT);
|
|
setState(672);
|
|
match(LPAREN);
|
|
setState(673);
|
|
expr();
|
|
setState(674);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SHAPE:
|
|
_localctx = new ShapeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 64);
|
|
{
|
|
setState(676);
|
|
match(SHAPE);
|
|
setState(677);
|
|
match(LPAREN);
|
|
setState(678);
|
|
expr();
|
|
setState(679);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case UPPER:
|
|
_localctx = new UpperFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 65);
|
|
{
|
|
setState(681);
|
|
match(UPPER);
|
|
setState(682);
|
|
match(LPAREN);
|
|
setState(683);
|
|
expr();
|
|
setState(684);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LOWER:
|
|
_localctx = new LowerFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 66);
|
|
{
|
|
setState(686);
|
|
match(LOWER);
|
|
setState(687);
|
|
match(LPAREN);
|
|
setState(688);
|
|
expr();
|
|
setState(689);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TRIM:
|
|
_localctx = new TrimFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 67);
|
|
{
|
|
setState(691);
|
|
match(TRIM);
|
|
setState(692);
|
|
match(LPAREN);
|
|
setState(693);
|
|
expr();
|
|
setState(694);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ENTROPY:
|
|
_localctx = new EntropyFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 68);
|
|
{
|
|
setState(696);
|
|
match(ENTROPY);
|
|
setState(697);
|
|
match(LPAREN);
|
|
setState(698);
|
|
expr();
|
|
setState(699);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SFFT:
|
|
_localctx = new SfftFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 69);
|
|
{
|
|
setState(701);
|
|
match(SFFT);
|
|
setState(702);
|
|
match(LPAREN);
|
|
setState(703);
|
|
expr();
|
|
setState(704);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case DILATE:
|
|
_localctx = new DilateFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 70);
|
|
{
|
|
setState(706);
|
|
match(DILATE);
|
|
setState(707);
|
|
match(LPAREN);
|
|
setState(708);
|
|
expr();
|
|
setState(711);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(709);
|
|
match(COMMA);
|
|
setState(710);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(713);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ERODE:
|
|
_localctx = new ErodeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 71);
|
|
{
|
|
setState(715);
|
|
match(ERODE);
|
|
setState(716);
|
|
match(LPAREN);
|
|
setState(717);
|
|
expr();
|
|
setState(720);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(718);
|
|
match(COMMA);
|
|
setState(719);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(722);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MORPH_OPEN:
|
|
_localctx = new MorphOpenFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 72);
|
|
{
|
|
setState(724);
|
|
match(MORPH_OPEN);
|
|
setState(725);
|
|
match(LPAREN);
|
|
setState(726);
|
|
expr();
|
|
setState(729);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(727);
|
|
match(COMMA);
|
|
setState(728);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(731);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MORPH_CLOSE:
|
|
_localctx = new MorphCloseFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 73);
|
|
{
|
|
setState(733);
|
|
match(MORPH_CLOSE);
|
|
setState(734);
|
|
match(LPAREN);
|
|
setState(735);
|
|
expr();
|
|
setState(738);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(736);
|
|
match(COMMA);
|
|
setState(737);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(740);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case INT:
|
|
_localctx = new IntFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 74);
|
|
{
|
|
setState(742);
|
|
match(INT);
|
|
setState(743);
|
|
match(LPAREN);
|
|
setState(744);
|
|
expr();
|
|
setState(745);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOAT:
|
|
_localctx = new FloatFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 75);
|
|
{
|
|
setState(747);
|
|
match(FLOAT);
|
|
setState(748);
|
|
match(LPAREN);
|
|
setState(749);
|
|
expr();
|
|
setState(750);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOW_MAG:
|
|
_localctx = new FlowMagFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 76);
|
|
{
|
|
setState(752);
|
|
match(FLOW_MAG);
|
|
setState(753);
|
|
match(LPAREN);
|
|
setState(754);
|
|
expr();
|
|
setState(755);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOW_ANG:
|
|
_localctx = new FlowAngFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 77);
|
|
{
|
|
setState(757);
|
|
match(FLOW_ANG);
|
|
setState(758);
|
|
match(LPAREN);
|
|
setState(759);
|
|
expr();
|
|
setState(760);
|
|
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 Func2Context extends ParserRuleContext {
|
|
public Func2Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func2; }
|
|
|
|
public Func2Context() { }
|
|
public void copyFrom(Func2Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CorrFuncContext extends Func2Context {
|
|
public TerminalNode CORR() { return getToken(MathExprParser.CORR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CorrFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCorrFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCorrFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCorrFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CovFuncContext extends Func2Context {
|
|
public TerminalNode COV() { return getToken(MathExprParser.COV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CovFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCovFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCovFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCovFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PadFuncContext extends Func2Context {
|
|
public TerminalNode PAD() { return getToken(MathExprParser.PAD, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PadFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPadFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPadFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPadFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterpolateAreaFuncContext extends Func2Context {
|
|
public TerminalNode INTERPOLATE_AREA() { return getToken(MathExprParser.INTERPOLATE_AREA, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public InterpolateAreaFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterInterpolateAreaFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitInterpolateAreaFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitInterpolateAreaFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BotkFuncContext extends Func2Context {
|
|
public TerminalNode BOTK() { return getToken(MathExprParser.BOTK, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BotkFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBotkFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBotkFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBotkFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BotkIndFuncContext extends Func2Context {
|
|
public TerminalNode BOTK_IND() { return getToken(MathExprParser.BOTK_IND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BotkIndFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBotkIndFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBotkIndFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBotkIndFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PowFuncContext extends Func2Context {
|
|
public TerminalNode POWE() { return getToken(MathExprParser.POWE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PowFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPowFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPowFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPowFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DotFuncContext extends Func2Context {
|
|
public TerminalNode DOT() { return getToken(MathExprParser.DOT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public DotFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterDotFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitDotFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitDotFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AppendFuncContext extends Func2Context {
|
|
public TerminalNode APPEND() { return getToken(MathExprParser.APPEND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public AppendFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAppendFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAppendFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAppendFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlipFuncContext extends Func2Context {
|
|
public TerminalNode FLIP() { return getToken(MathExprParser.FLIP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlipFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlipFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlipFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlipFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitAndFuncContext extends Func2Context {
|
|
public TerminalNode BAND() { return getToken(MathExprParser.BAND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BitAndFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBitAndFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBitAndFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBitAndFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SplitFuncContext extends Func2Context {
|
|
public TerminalNode SPLIT() { return getToken(MathExprParser.SPLIT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public SplitFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSplitFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSplitFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSplitFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PermuteFuncContext extends Func2Context {
|
|
public TerminalNode PERM() { return getToken(MathExprParser.PERM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PermuteFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPermuteFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPermuteFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPermuteFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitOrFuncContext extends Func2Context {
|
|
public TerminalNode BOR() { return getToken(MathExprParser.BOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BitOrFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBitOrFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBitOrFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBitOrFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterpolateLinearFuncContext extends Func2Context {
|
|
public TerminalNode INTERPOLATE_LINEAR() { return getToken(MathExprParser.INTERPOLATE_LINEAR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public InterpolateLinearFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterInterpolateLinearFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitInterpolateLinearFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitInterpolateLinearFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EmptyTensorFuncContext extends Func2Context {
|
|
public TerminalNode TENSOR() { return getToken(MathExprParser.TENSOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public IndexExprContext indexExpr() {
|
|
return getRuleContext(IndexExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public EmptyTensorFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterEmptyTensorFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitEmptyTensorFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitEmptyTensorFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TopkFuncContext extends Func2Context {
|
|
public TerminalNode TOPK() { return getToken(MathExprParser.TOPK, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TopkFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTopkFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTopkFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTopkFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PercentileFuncContext extends Func2Context {
|
|
public TerminalNode PERCENTILE() { return getToken(MathExprParser.PERCENTILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PercentileFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPercentileFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPercentileFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPercentileFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TopkIndFuncContext extends Func2Context {
|
|
public TerminalNode TOPK_IND() { return getToken(MathExprParser.TOPK_IND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TopkIndFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTopkIndFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTopkIndFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTopkIndFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FlowApplyFuncContext extends Func2Context {
|
|
public TerminalNode FLOW_APPLY() { return getToken(MathExprParser.FLOW_APPLY, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FlowApplyFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFlowApplyFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFlowApplyFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFlowApplyFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BatchShuffleFuncContext extends Func2Context {
|
|
public TerminalNode BATCH_SHUFFLE() { return getToken(MathExprParser.BATCH_SHUFFLE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BatchShuffleFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBatchShuffleFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBatchShuffleFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBatchShuffleFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FindFuncContext extends Func2Context {
|
|
public TerminalNode FIND() { return getToken(MathExprParser.FIND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public FindFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterFindFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitFindFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitFindFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Int_to_rgbFuncContext extends Func2Context {
|
|
public TerminalNode INT_TO_RGB() { return getToken(MathExprParser.INT_TO_RGB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public Int_to_rgbFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterInt_to_rgbFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitInt_to_rgbFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitInt_to_rgbFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MatmulFuncContext extends Func2Context {
|
|
public TerminalNode MATMUL() { return getToken(MathExprParser.MATMUL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public MatmulFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMatmulFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMatmulFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMatmulFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StepFuncContext extends Func2Context {
|
|
public TerminalNode STEP() { return getToken(MathExprParser.STEP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public StepFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterStepFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitStepFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitStepFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class JoinFuncContext extends Func2Context {
|
|
public TerminalNode JOIN() { return getToken(MathExprParser.JOIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public JoinFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterJoinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitJoinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitJoinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Atan2FuncContext extends Func2Context {
|
|
public TerminalNode ATAN2() { return getToken(MathExprParser.ATAN2, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public Atan2FuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterAtan2Func(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitAtan2Func(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitAtan2Func(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class QuantileFuncContext extends Func2Context {
|
|
public TerminalNode QUANTILE() { return getToken(MathExprParser.QUANTILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public QuantileFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterQuantileFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitQuantileFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitQuantileFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterpolateNearestExactFuncContext extends Func2Context {
|
|
public TerminalNode INTERPOLATE_NEAREST() { return getToken(MathExprParser.INTERPOLATE_NEAREST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public InterpolateNearestExactFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterInterpolateNearestExactFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitInterpolateNearestExactFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitInterpolateNearestExactFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitXorFuncContext extends Func2Context {
|
|
public TerminalNode XOR() { return getToken(MathExprParser.XOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BitXorFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBitXorFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBitXorFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBitXorFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Rgb_to_intFuncContext extends Func2Context {
|
|
public TerminalNode RGB_TO_INT() { return getToken(MathExprParser.RGB_TO_INT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public Rgb_to_intFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRgb_to_intFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRgb_to_intFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRgb_to_intFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TMaxFuncContext extends Func2Context {
|
|
public TerminalNode TMAX() { return getToken(MathExprParser.TMAX, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TMaxFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTMaxFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTMaxFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTMaxFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PushFuncContext extends Func2Context {
|
|
public TerminalNode PUSH() { return getToken(MathExprParser.PUSH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PushFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPushFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPushFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPushFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GetValueFuncContext extends Func2Context {
|
|
public TerminalNode GET_VALUE() { return getToken(MathExprParser.GET_VALUE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GetValueFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGetValueFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGetValueFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGetValueFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CossimFuncContext extends Func2Context {
|
|
public TerminalNode COSSIM() { return getToken(MathExprParser.COSSIM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CossimFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCossimFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCossimFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCossimFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CrossFuncContext extends Func2Context {
|
|
public TerminalNode CROSS() { return getToken(MathExprParser.CROSS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CrossFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCrossFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCrossFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCrossFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RifeFuncContext extends Func2Context {
|
|
public TerminalNode RIFE() { return getToken(MathExprParser.RIFE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public RifeFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRifeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRifeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRifeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GaussianFuncContext extends Func2Context {
|
|
public TerminalNode GAUSSIAN() { return getToken(MathExprParser.GAUSSIAN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GaussianFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGaussianFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGaussianFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGaussianFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SubstringFuncContext extends Func2Context {
|
|
public TerminalNode SUBSTRING() { return getToken(MathExprParser.SUBSTRING, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode SUBSTR() { return getToken(MathExprParser.SUBSTR, 0); }
|
|
public SubstringFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSubstringFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSubstringFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSubstringFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class QuartileFuncContext extends Func2Context {
|
|
public TerminalNode QUARTILE() { return getToken(MathExprParser.QUARTILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public QuartileFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterQuartileFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitQuartileFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitQuartileFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TMinFuncContext extends Func2Context {
|
|
public TerminalNode TMIN() { return getToken(MathExprParser.TMIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TMinFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterTMinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitTMinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitTMinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReplaceFuncContext extends Func2Context {
|
|
public TerminalNode REPLACE() { return getToken(MathExprParser.REPLACE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ReplaceFuncContext(Func2Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterReplaceFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitReplaceFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitReplaceFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func2Context func2() throws RecognitionException {
|
|
Func2Context _localctx = new Func2Context(_ctx, getState());
|
|
enterRule(_localctx, 50, RULE_func2);
|
|
int _la;
|
|
try {
|
|
setState(1104);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case POWE:
|
|
_localctx = new PowFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(764);
|
|
match(POWE);
|
|
setState(765);
|
|
match(LPAREN);
|
|
setState(766);
|
|
expr();
|
|
setState(767);
|
|
match(COMMA);
|
|
setState(768);
|
|
expr();
|
|
setState(769);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ATAN2:
|
|
_localctx = new Atan2FuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(771);
|
|
match(ATAN2);
|
|
setState(772);
|
|
match(LPAREN);
|
|
setState(773);
|
|
expr();
|
|
setState(774);
|
|
match(COMMA);
|
|
setState(775);
|
|
expr();
|
|
setState(776);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TMIN:
|
|
_localctx = new TMinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(778);
|
|
match(TMIN);
|
|
setState(779);
|
|
match(LPAREN);
|
|
setState(780);
|
|
expr();
|
|
setState(781);
|
|
match(COMMA);
|
|
setState(782);
|
|
expr();
|
|
setState(783);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TMAX:
|
|
_localctx = new TMaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(785);
|
|
match(TMAX);
|
|
setState(786);
|
|
match(LPAREN);
|
|
setState(787);
|
|
expr();
|
|
setState(788);
|
|
match(COMMA);
|
|
setState(789);
|
|
expr();
|
|
setState(790);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case STEP:
|
|
_localctx = new StepFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(792);
|
|
match(STEP);
|
|
setState(793);
|
|
match(LPAREN);
|
|
setState(794);
|
|
expr();
|
|
setState(795);
|
|
match(COMMA);
|
|
setState(796);
|
|
expr();
|
|
setState(797);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TOPK:
|
|
_localctx = new TopkFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(799);
|
|
match(TOPK);
|
|
setState(800);
|
|
match(LPAREN);
|
|
setState(801);
|
|
expr();
|
|
setState(802);
|
|
match(COMMA);
|
|
setState(803);
|
|
expr();
|
|
setState(804);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BOTK:
|
|
_localctx = new BotkFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(806);
|
|
match(BOTK);
|
|
setState(807);
|
|
match(LPAREN);
|
|
setState(808);
|
|
expr();
|
|
setState(809);
|
|
match(COMMA);
|
|
setState(810);
|
|
expr();
|
|
setState(811);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case QUARTILE:
|
|
_localctx = new QuartileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(813);
|
|
match(QUARTILE);
|
|
setState(814);
|
|
match(LPAREN);
|
|
setState(815);
|
|
expr();
|
|
setState(816);
|
|
match(COMMA);
|
|
setState(817);
|
|
expr();
|
|
setState(818);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PERCENTILE:
|
|
_localctx = new PercentileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(820);
|
|
match(PERCENTILE);
|
|
setState(821);
|
|
match(LPAREN);
|
|
setState(822);
|
|
expr();
|
|
setState(823);
|
|
match(COMMA);
|
|
setState(824);
|
|
expr();
|
|
setState(825);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case QUANTILE:
|
|
_localctx = new QuantileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(827);
|
|
match(QUANTILE);
|
|
setState(828);
|
|
match(LPAREN);
|
|
setState(829);
|
|
expr();
|
|
setState(830);
|
|
match(COMMA);
|
|
setState(831);
|
|
expr();
|
|
setState(832);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case DOT:
|
|
_localctx = new DotFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(834);
|
|
match(DOT);
|
|
setState(835);
|
|
match(LPAREN);
|
|
setState(836);
|
|
expr();
|
|
setState(837);
|
|
match(COMMA);
|
|
setState(838);
|
|
expr();
|
|
setState(839);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COSSIM:
|
|
_localctx = new CossimFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(841);
|
|
match(COSSIM);
|
|
setState(842);
|
|
match(LPAREN);
|
|
setState(843);
|
|
expr();
|
|
setState(844);
|
|
match(COMMA);
|
|
setState(845);
|
|
expr();
|
|
setState(846);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLIP:
|
|
_localctx = new FlipFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(848);
|
|
match(FLIP);
|
|
setState(849);
|
|
match(LPAREN);
|
|
setState(850);
|
|
expr();
|
|
setState(851);
|
|
match(COMMA);
|
|
setState(852);
|
|
expr();
|
|
setState(853);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COV:
|
|
_localctx = new CovFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(855);
|
|
match(COV);
|
|
setState(856);
|
|
match(LPAREN);
|
|
setState(857);
|
|
expr();
|
|
setState(858);
|
|
match(COMMA);
|
|
setState(859);
|
|
expr();
|
|
setState(860);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CORR:
|
|
_localctx = new CorrFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(862);
|
|
match(CORR);
|
|
setState(863);
|
|
match(LPAREN);
|
|
setState(864);
|
|
expr();
|
|
setState(865);
|
|
match(COMMA);
|
|
setState(866);
|
|
expr();
|
|
setState(867);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case APPEND:
|
|
_localctx = new AppendFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(869);
|
|
match(APPEND);
|
|
setState(870);
|
|
match(LPAREN);
|
|
setState(871);
|
|
expr();
|
|
setState(872);
|
|
match(COMMA);
|
|
setState(873);
|
|
expr();
|
|
setState(874);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PERM:
|
|
_localctx = new PermuteFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(876);
|
|
match(PERM);
|
|
setState(877);
|
|
match(LPAREN);
|
|
setState(878);
|
|
expr();
|
|
setState(879);
|
|
match(COMMA);
|
|
setState(880);
|
|
expr();
|
|
setState(881);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GAUSSIAN:
|
|
_localctx = new GaussianFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(883);
|
|
match(GAUSSIAN);
|
|
setState(884);
|
|
match(LPAREN);
|
|
setState(885);
|
|
expr();
|
|
setState(886);
|
|
match(COMMA);
|
|
setState(887);
|
|
expr();
|
|
setState(890);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(888);
|
|
match(COMMA);
|
|
setState(889);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(892);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TOPK_IND:
|
|
_localctx = new TopkIndFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 19);
|
|
{
|
|
setState(894);
|
|
match(TOPK_IND);
|
|
setState(895);
|
|
match(LPAREN);
|
|
setState(896);
|
|
expr();
|
|
setState(897);
|
|
match(COMMA);
|
|
setState(898);
|
|
expr();
|
|
setState(899);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BOTK_IND:
|
|
_localctx = new BotkIndFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 20);
|
|
{
|
|
setState(901);
|
|
match(BOTK_IND);
|
|
setState(902);
|
|
match(LPAREN);
|
|
setState(903);
|
|
expr();
|
|
setState(904);
|
|
match(COMMA);
|
|
setState(905);
|
|
expr();
|
|
setState(906);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BATCH_SHUFFLE:
|
|
_localctx = new BatchShuffleFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 21);
|
|
{
|
|
setState(908);
|
|
match(BATCH_SHUFFLE);
|
|
setState(909);
|
|
match(LPAREN);
|
|
setState(910);
|
|
expr();
|
|
setState(911);
|
|
match(COMMA);
|
|
setState(912);
|
|
expr();
|
|
setState(913);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PUSH:
|
|
_localctx = new PushFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 22);
|
|
{
|
|
setState(915);
|
|
match(PUSH);
|
|
setState(916);
|
|
match(LPAREN);
|
|
setState(917);
|
|
expr();
|
|
setState(918);
|
|
match(COMMA);
|
|
setState(919);
|
|
expr();
|
|
setState(920);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GET_VALUE:
|
|
_localctx = new GetValueFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 23);
|
|
{
|
|
setState(922);
|
|
match(GET_VALUE);
|
|
setState(923);
|
|
match(LPAREN);
|
|
setState(924);
|
|
expr();
|
|
setState(925);
|
|
match(COMMA);
|
|
setState(926);
|
|
expr();
|
|
setState(927);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TENSOR:
|
|
_localctx = new EmptyTensorFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 24);
|
|
{
|
|
setState(929);
|
|
match(TENSOR);
|
|
setState(930);
|
|
match(LPAREN);
|
|
setState(931);
|
|
indexExpr(0);
|
|
setState(938);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(932);
|
|
match(COMMA);
|
|
setState(933);
|
|
expr();
|
|
setState(936);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(934);
|
|
match(COMMA);
|
|
setState(935);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
setState(940);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PAD:
|
|
_localctx = new PadFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 25);
|
|
{
|
|
setState(942);
|
|
match(PAD);
|
|
setState(943);
|
|
match(LPAREN);
|
|
setState(944);
|
|
expr();
|
|
setState(945);
|
|
match(COMMA);
|
|
setState(946);
|
|
expr();
|
|
setState(947);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CROSS:
|
|
_localctx = new CrossFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 26);
|
|
{
|
|
setState(949);
|
|
match(CROSS);
|
|
setState(950);
|
|
match(LPAREN);
|
|
setState(951);
|
|
expr();
|
|
setState(952);
|
|
match(COMMA);
|
|
setState(953);
|
|
expr();
|
|
setState(954);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MATMUL:
|
|
_localctx = new MatmulFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 27);
|
|
{
|
|
setState(956);
|
|
match(MATMUL);
|
|
setState(957);
|
|
match(LPAREN);
|
|
setState(958);
|
|
expr();
|
|
setState(959);
|
|
match(COMMA);
|
|
setState(960);
|
|
expr();
|
|
setState(961);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOW_APPLY:
|
|
_localctx = new FlowApplyFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 28);
|
|
{
|
|
setState(963);
|
|
match(FLOW_APPLY);
|
|
setState(964);
|
|
match(LPAREN);
|
|
setState(965);
|
|
expr();
|
|
setState(966);
|
|
match(COMMA);
|
|
setState(967);
|
|
expr();
|
|
setState(968);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RIFE:
|
|
_localctx = new RifeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 29);
|
|
{
|
|
setState(970);
|
|
match(RIFE);
|
|
setState(971);
|
|
match(LPAREN);
|
|
setState(972);
|
|
expr();
|
|
setState(973);
|
|
match(COMMA);
|
|
setState(974);
|
|
expr();
|
|
setState(985);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(975);
|
|
match(COMMA);
|
|
setState(976);
|
|
expr();
|
|
setState(983);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(977);
|
|
match(COMMA);
|
|
setState(978);
|
|
expr();
|
|
setState(981);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(979);
|
|
match(COMMA);
|
|
setState(980);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
setState(987);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BAND:
|
|
_localctx = new BitAndFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 30);
|
|
{
|
|
setState(989);
|
|
match(BAND);
|
|
setState(990);
|
|
match(LPAREN);
|
|
setState(991);
|
|
expr();
|
|
setState(992);
|
|
match(COMMA);
|
|
setState(993);
|
|
expr();
|
|
setState(994);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case XOR:
|
|
_localctx = new BitXorFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 31);
|
|
{
|
|
setState(996);
|
|
match(XOR);
|
|
setState(997);
|
|
match(LPAREN);
|
|
setState(998);
|
|
expr();
|
|
setState(999);
|
|
match(COMMA);
|
|
setState(1000);
|
|
expr();
|
|
setState(1001);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BOR:
|
|
_localctx = new BitOrFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 32);
|
|
{
|
|
setState(1003);
|
|
match(BOR);
|
|
setState(1004);
|
|
match(LPAREN);
|
|
setState(1005);
|
|
expr();
|
|
setState(1006);
|
|
match(COMMA);
|
|
setState(1007);
|
|
expr();
|
|
setState(1008);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SPLIT:
|
|
_localctx = new SplitFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 33);
|
|
{
|
|
setState(1010);
|
|
match(SPLIT);
|
|
setState(1011);
|
|
match(LPAREN);
|
|
setState(1012);
|
|
expr();
|
|
setState(1015);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1013);
|
|
match(COMMA);
|
|
setState(1014);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1017);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case JOIN:
|
|
_localctx = new JoinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 34);
|
|
{
|
|
setState(1019);
|
|
match(JOIN);
|
|
setState(1020);
|
|
match(LPAREN);
|
|
setState(1021);
|
|
expr();
|
|
setState(1024);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1022);
|
|
match(COMMA);
|
|
setState(1023);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1026);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SUBSTRING:
|
|
_localctx = new SubstringFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 35);
|
|
{
|
|
setState(1028);
|
|
match(SUBSTRING);
|
|
setState(1029);
|
|
match(LPAREN);
|
|
setState(1030);
|
|
expr();
|
|
setState(1031);
|
|
match(COMMA);
|
|
setState(1032);
|
|
expr();
|
|
setState(1035);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1033);
|
|
match(COMMA);
|
|
setState(1034);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1037);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SUBSTR:
|
|
_localctx = new SubstringFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 36);
|
|
{
|
|
setState(1039);
|
|
match(SUBSTR);
|
|
setState(1040);
|
|
match(LPAREN);
|
|
setState(1041);
|
|
expr();
|
|
setState(1042);
|
|
match(COMMA);
|
|
setState(1043);
|
|
expr();
|
|
setState(1046);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1044);
|
|
match(COMMA);
|
|
setState(1045);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1048);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FIND:
|
|
_localctx = new FindFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 37);
|
|
{
|
|
setState(1050);
|
|
match(FIND);
|
|
setState(1051);
|
|
match(LPAREN);
|
|
setState(1052);
|
|
expr();
|
|
setState(1053);
|
|
match(COMMA);
|
|
setState(1054);
|
|
expr();
|
|
setState(1055);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case REPLACE:
|
|
_localctx = new ReplaceFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 38);
|
|
{
|
|
setState(1057);
|
|
match(REPLACE);
|
|
setState(1058);
|
|
match(LPAREN);
|
|
setState(1059);
|
|
expr();
|
|
setState(1060);
|
|
match(COMMA);
|
|
setState(1061);
|
|
expr();
|
|
setState(1062);
|
|
match(COMMA);
|
|
setState(1063);
|
|
expr();
|
|
setState(1064);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case INT_TO_RGB:
|
|
_localctx = new Int_to_rgbFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 39);
|
|
{
|
|
setState(1066);
|
|
match(INT_TO_RGB);
|
|
setState(1067);
|
|
match(LPAREN);
|
|
setState(1068);
|
|
expr();
|
|
setState(1069);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RGB_TO_INT:
|
|
_localctx = new Rgb_to_intFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 40);
|
|
{
|
|
setState(1071);
|
|
match(RGB_TO_INT);
|
|
setState(1072);
|
|
match(LPAREN);
|
|
setState(1073);
|
|
expr();
|
|
setState(1079);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1074);
|
|
match(COMMA);
|
|
setState(1075);
|
|
expr();
|
|
setState(1076);
|
|
match(COMMA);
|
|
setState(1077);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1081);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case INTERPOLATE_LINEAR:
|
|
_localctx = new InterpolateLinearFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 41);
|
|
{
|
|
setState(1083);
|
|
match(INTERPOLATE_LINEAR);
|
|
setState(1084);
|
|
match(LPAREN);
|
|
setState(1085);
|
|
expr();
|
|
setState(1086);
|
|
match(COMMA);
|
|
setState(1087);
|
|
expr();
|
|
setState(1088);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case INTERPOLATE_AREA:
|
|
_localctx = new InterpolateAreaFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 42);
|
|
{
|
|
setState(1090);
|
|
match(INTERPOLATE_AREA);
|
|
setState(1091);
|
|
match(LPAREN);
|
|
setState(1092);
|
|
expr();
|
|
setState(1093);
|
|
match(COMMA);
|
|
setState(1094);
|
|
expr();
|
|
setState(1095);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case INTERPOLATE_NEAREST:
|
|
_localctx = new InterpolateNearestExactFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 43);
|
|
{
|
|
setState(1097);
|
|
match(INTERPOLATE_NEAREST);
|
|
setState(1098);
|
|
match(LPAREN);
|
|
setState(1099);
|
|
expr();
|
|
setState(1100);
|
|
match(COMMA);
|
|
setState(1101);
|
|
expr();
|
|
setState(1102);
|
|
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 Func3Context extends ParserRuleContext {
|
|
public Func3Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func3; }
|
|
|
|
public Func3Context() { }
|
|
public void copyFrom(Func3Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SmootherstepFuncContext extends Func3Context {
|
|
public TerminalNode SMOOTHERSTEP() { return getToken(MathExprParser.SMOOTHERSTEP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SmootherstepFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSmootherstepFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSmootherstepFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSmootherstepFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhereFuncContext extends Func3Context {
|
|
public TerminalNode WHERE() { return getToken(MathExprParser.WHERE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public WhereFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterWhereFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitWhereFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitWhereFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RgbToOklabFuncContext extends Func3Context {
|
|
public TerminalNode RGB_TO_OKLAB() { return getToken(MathExprParser.RGB_TO_OKLAB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public RgbToOklabFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRgbToOklabFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRgbToOklabFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRgbToOklabFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CubicEaseFuncContext extends Func3Context {
|
|
public TerminalNode CUBIC_EASE() { return getToken(MathExprParser.CUBIC_EASE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CubicEaseFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCubicEaseFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCubicEaseFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCubicEaseFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class HsvToRgbFuncContext extends Func3Context {
|
|
public TerminalNode HSV_TO_RGB() { return getToken(MathExprParser.HSV_TO_RGB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public HsvToRgbFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterHsvToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitHsvToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitHsvToRgbFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SmoothstepFuncContext extends Func3Context {
|
|
public TerminalNode SMOOTHSTEP() { return getToken(MathExprParser.SMOOTHSTEP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SmoothstepFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSmoothstepFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSmoothstepFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSmoothstepFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LinspaceFuncContext extends Func3Context {
|
|
public TerminalNode LINSPACE() { return getToken(MathExprParser.LINSPACE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LinspaceFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLinspaceFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLinspaceFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLinspaceFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class OklabToRgbFuncContext extends Func3Context {
|
|
public TerminalNode OKLAB_TO_RGB() { return getToken(MathExprParser.OKLAB_TO_RGB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public OklabToRgbFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterOklabToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitOklabToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitOklabToRgbFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClampFuncContext extends Func3Context {
|
|
public TerminalNode CLAMP() { return getToken(MathExprParser.CLAMP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ClampFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterClampFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitClampFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitClampFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SineEaseFuncContext extends Func3Context {
|
|
public TerminalNode SINE_EASE() { return getToken(MathExprParser.SINE_EASE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SineEaseFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSineEaseFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSineEaseFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSineEaseFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class OverlayFuncContext extends Func3Context {
|
|
public TerminalNode OVERLAY() { return getToken(MathExprParser.OVERLAY, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public OverlayFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterOverlayFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitOverlayFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitOverlayFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CilabToRgbFuncContext extends Func3Context {
|
|
public TerminalNode CILAB_TO_RGB() { return getToken(MathExprParser.CILAB_TO_RGB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public CilabToRgbFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCilabToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCilabToRgbFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCilabToRgbFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RollFuncContext extends Func3Context {
|
|
public TerminalNode ROLL() { return getToken(MathExprParser.ROLL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public RollFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRollFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRollFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRollFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MomentFuncContext extends Func3Context {
|
|
public TerminalNode MOMENT() { return getToken(MathExprParser.MOMENT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public MomentFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMomentFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMomentFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMomentFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LerpFuncContext extends Func3Context {
|
|
public TerminalNode LERP() { return getToken(MathExprParser.LERP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LerpFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLerpFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLerpFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLerpFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RgbToHsvFuncContext extends Func3Context {
|
|
public TerminalNode RGB_TO_HSV() { return getToken(MathExprParser.RGB_TO_HSV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public RgbToHsvFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRgbToHsvFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRgbToHsvFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRgbToHsvFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SifftFuncContext extends Func3Context {
|
|
public TerminalNode SIFFT() { return getToken(MathExprParser.SIFFT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public SifftFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSifftFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSifftFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSifftFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RgbToCilabFuncContext extends Func3Context {
|
|
public TerminalNode RGB_TO_CILAB() { return getToken(MathExprParser.RGB_TO_CILAB, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public RgbToCilabFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRgbToCilabFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRgbToCilabFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRgbToCilabFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElasticEaseFuncContext extends Func3Context {
|
|
public TerminalNode ELASTIC_EASE() { return getToken(MathExprParser.ELASTIC_EASE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ElasticEaseFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterElasticEaseFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitElasticEaseFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitElasticEaseFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RangeFuncContext extends Func3Context {
|
|
public TerminalNode RANGE() { return getToken(MathExprParser.RANGE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public RangeFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRangeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRangeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRangeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CropFuncContext extends Func3Context {
|
|
public TerminalNode CROP() { return getToken(MathExprParser.CROP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CropFuncContext(Func3Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCropFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCropFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCropFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func3Context func3() throws RecognitionException {
|
|
Func3Context _localctx = new Func3Context(_ctx, getState());
|
|
enterRule(_localctx, 52, RULE_func3);
|
|
int _la;
|
|
try {
|
|
setState(1327);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case CLAMP:
|
|
_localctx = new ClampFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1106);
|
|
match(CLAMP);
|
|
setState(1107);
|
|
match(LPAREN);
|
|
setState(1108);
|
|
expr();
|
|
setState(1109);
|
|
match(COMMA);
|
|
setState(1110);
|
|
expr();
|
|
setState(1111);
|
|
match(COMMA);
|
|
setState(1112);
|
|
expr();
|
|
setState(1113);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LERP:
|
|
_localctx = new LerpFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1115);
|
|
match(LERP);
|
|
setState(1116);
|
|
match(LPAREN);
|
|
setState(1117);
|
|
expr();
|
|
setState(1118);
|
|
match(COMMA);
|
|
setState(1119);
|
|
expr();
|
|
setState(1120);
|
|
match(COMMA);
|
|
setState(1121);
|
|
expr();
|
|
setState(1122);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SMOOTHSTEP:
|
|
_localctx = new SmoothstepFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1124);
|
|
match(SMOOTHSTEP);
|
|
setState(1125);
|
|
match(LPAREN);
|
|
setState(1126);
|
|
expr();
|
|
setState(1127);
|
|
match(COMMA);
|
|
setState(1128);
|
|
expr();
|
|
setState(1129);
|
|
match(COMMA);
|
|
setState(1130);
|
|
expr();
|
|
setState(1131);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RANGE:
|
|
_localctx = new RangeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1133);
|
|
match(RANGE);
|
|
setState(1134);
|
|
match(LPAREN);
|
|
setState(1135);
|
|
expr();
|
|
setState(1136);
|
|
match(COMMA);
|
|
setState(1137);
|
|
expr();
|
|
setState(1138);
|
|
match(COMMA);
|
|
setState(1139);
|
|
expr();
|
|
setState(1140);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MOMENT:
|
|
_localctx = new MomentFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1142);
|
|
match(MOMENT);
|
|
setState(1143);
|
|
match(LPAREN);
|
|
setState(1144);
|
|
expr();
|
|
setState(1145);
|
|
match(COMMA);
|
|
setState(1146);
|
|
expr();
|
|
setState(1147);
|
|
match(COMMA);
|
|
setState(1148);
|
|
expr();
|
|
setState(1149);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CUBIC_EASE:
|
|
_localctx = new CubicEaseFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1151);
|
|
match(CUBIC_EASE);
|
|
setState(1152);
|
|
match(LPAREN);
|
|
setState(1153);
|
|
expr();
|
|
setState(1154);
|
|
match(COMMA);
|
|
setState(1155);
|
|
expr();
|
|
setState(1156);
|
|
match(COMMA);
|
|
setState(1157);
|
|
expr();
|
|
setState(1158);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ELASTIC_EASE:
|
|
_localctx = new ElasticEaseFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1160);
|
|
match(ELASTIC_EASE);
|
|
setState(1161);
|
|
match(LPAREN);
|
|
setState(1162);
|
|
expr();
|
|
setState(1163);
|
|
match(COMMA);
|
|
setState(1164);
|
|
expr();
|
|
setState(1165);
|
|
match(COMMA);
|
|
setState(1166);
|
|
expr();
|
|
setState(1167);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SINE_EASE:
|
|
_localctx = new SineEaseFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1169);
|
|
match(SINE_EASE);
|
|
setState(1170);
|
|
match(LPAREN);
|
|
setState(1171);
|
|
expr();
|
|
setState(1172);
|
|
match(COMMA);
|
|
setState(1173);
|
|
expr();
|
|
setState(1174);
|
|
match(COMMA);
|
|
setState(1175);
|
|
expr();
|
|
setState(1176);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SMOOTHERSTEP:
|
|
_localctx = new SmootherstepFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1178);
|
|
match(SMOOTHERSTEP);
|
|
setState(1179);
|
|
match(LPAREN);
|
|
setState(1180);
|
|
expr();
|
|
setState(1181);
|
|
match(COMMA);
|
|
setState(1182);
|
|
expr();
|
|
setState(1183);
|
|
match(COMMA);
|
|
setState(1184);
|
|
expr();
|
|
setState(1185);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CROP:
|
|
_localctx = new CropFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1187);
|
|
match(CROP);
|
|
setState(1188);
|
|
match(LPAREN);
|
|
setState(1189);
|
|
expr();
|
|
setState(1190);
|
|
match(COMMA);
|
|
setState(1191);
|
|
expr();
|
|
setState(1192);
|
|
match(COMMA);
|
|
setState(1193);
|
|
expr();
|
|
setState(1194);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIFFT:
|
|
_localctx = new SifftFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1196);
|
|
match(SIFFT);
|
|
setState(1197);
|
|
match(LPAREN);
|
|
setState(1198);
|
|
expr();
|
|
setState(1201);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1199);
|
|
match(COMMA);
|
|
setState(1200);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1203);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case OVERLAY:
|
|
_localctx = new OverlayFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(1205);
|
|
match(OVERLAY);
|
|
setState(1206);
|
|
match(LPAREN);
|
|
setState(1207);
|
|
expr();
|
|
setState(1208);
|
|
match(COMMA);
|
|
setState(1209);
|
|
expr();
|
|
setState(1210);
|
|
match(COMMA);
|
|
setState(1211);
|
|
expr();
|
|
setState(1214);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1212);
|
|
match(COMMA);
|
|
setState(1213);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1216);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LINSPACE:
|
|
_localctx = new LinspaceFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(1218);
|
|
match(LINSPACE);
|
|
setState(1219);
|
|
match(LPAREN);
|
|
setState(1220);
|
|
expr();
|
|
setState(1221);
|
|
match(COMMA);
|
|
setState(1222);
|
|
expr();
|
|
setState(1223);
|
|
match(COMMA);
|
|
setState(1224);
|
|
expr();
|
|
setState(1225);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ROLL:
|
|
_localctx = new RollFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(1227);
|
|
match(ROLL);
|
|
setState(1228);
|
|
match(LPAREN);
|
|
setState(1229);
|
|
expr();
|
|
setState(1230);
|
|
match(COMMA);
|
|
setState(1231);
|
|
expr();
|
|
setState(1234);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1232);
|
|
match(COMMA);
|
|
setState(1233);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1236);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RGB_TO_OKLAB:
|
|
_localctx = new RgbToOklabFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(1238);
|
|
match(RGB_TO_OKLAB);
|
|
setState(1239);
|
|
match(LPAREN);
|
|
setState(1240);
|
|
expr();
|
|
setState(1246);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1241);
|
|
match(COMMA);
|
|
setState(1242);
|
|
expr();
|
|
setState(1243);
|
|
match(COMMA);
|
|
setState(1244);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1248);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RGB_TO_CILAB:
|
|
_localctx = new RgbToCilabFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(1250);
|
|
match(RGB_TO_CILAB);
|
|
setState(1251);
|
|
match(LPAREN);
|
|
setState(1252);
|
|
expr();
|
|
setState(1258);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1253);
|
|
match(COMMA);
|
|
setState(1254);
|
|
expr();
|
|
setState(1255);
|
|
match(COMMA);
|
|
setState(1256);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1260);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RGB_TO_HSV:
|
|
_localctx = new RgbToHsvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(1262);
|
|
match(RGB_TO_HSV);
|
|
setState(1263);
|
|
match(LPAREN);
|
|
setState(1264);
|
|
expr();
|
|
setState(1270);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1265);
|
|
match(COMMA);
|
|
setState(1266);
|
|
expr();
|
|
setState(1267);
|
|
match(COMMA);
|
|
setState(1268);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1274);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1272);
|
|
match(COMMA);
|
|
setState(1273);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1276);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case HSV_TO_RGB:
|
|
_localctx = new HsvToRgbFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(1278);
|
|
match(HSV_TO_RGB);
|
|
setState(1279);
|
|
match(LPAREN);
|
|
setState(1280);
|
|
expr();
|
|
setState(1286);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1281);
|
|
match(COMMA);
|
|
setState(1282);
|
|
expr();
|
|
setState(1283);
|
|
match(COMMA);
|
|
setState(1284);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1290);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1288);
|
|
match(COMMA);
|
|
setState(1289);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1292);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case WHERE:
|
|
_localctx = new WhereFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 19);
|
|
{
|
|
setState(1294);
|
|
match(WHERE);
|
|
setState(1295);
|
|
match(LPAREN);
|
|
setState(1296);
|
|
expr();
|
|
setState(1297);
|
|
match(COMMA);
|
|
setState(1298);
|
|
expr();
|
|
setState(1299);
|
|
match(COMMA);
|
|
setState(1300);
|
|
expr();
|
|
setState(1301);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case OKLAB_TO_RGB:
|
|
_localctx = new OklabToRgbFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 20);
|
|
{
|
|
setState(1303);
|
|
match(OKLAB_TO_RGB);
|
|
setState(1304);
|
|
match(LPAREN);
|
|
setState(1305);
|
|
expr();
|
|
setState(1311);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1306);
|
|
match(COMMA);
|
|
setState(1307);
|
|
expr();
|
|
setState(1308);
|
|
match(COMMA);
|
|
setState(1309);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1313);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CILAB_TO_RGB:
|
|
_localctx = new CilabToRgbFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 21);
|
|
{
|
|
setState(1315);
|
|
match(CILAB_TO_RGB);
|
|
setState(1316);
|
|
match(LPAREN);
|
|
setState(1317);
|
|
expr();
|
|
setState(1323);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1318);
|
|
match(COMMA);
|
|
setState(1319);
|
|
expr();
|
|
setState(1320);
|
|
match(COMMA);
|
|
setState(1321);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1325);
|
|
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 Func4Context extends ParserRuleContext {
|
|
public Func4Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func4; }
|
|
|
|
public Func4Context() { }
|
|
public void copyFrom(Func4Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DistFuncContext extends Func4Context {
|
|
public TerminalNode DIST() { return getToken(MathExprParser.DIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public DistFuncContext(Func4Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class HistogramFuncContext extends Func4Context {
|
|
public TerminalNode HISTOGRAM() { return getToken(MathExprParser.HISTOGRAM, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public HistogramFuncContext(Func4Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterHistogramFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitHistogramFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitHistogramFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LogspaceFuncContext extends Func4Context {
|
|
public TerminalNode LOGSPACE() { return getToken(MathExprParser.LOGSPACE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LogspaceFuncContext(Func4Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLogspaceFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLogspaceFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLogspaceFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NvlFuncContext extends Func4Context {
|
|
public TerminalNode NVL() { return getToken(MathExprParser.NVL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public NvlFuncContext(Func4Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterNvlFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitNvlFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitNvlFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwapFuncContext extends Func4Context {
|
|
public TerminalNode SWAP() { return getToken(MathExprParser.SWAP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public SwapFuncContext(Func4Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSwapFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSwapFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSwapFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func4Context func4() throws RecognitionException {
|
|
Func4Context _localctx = new Func4Context(_ctx, getState());
|
|
enterRule(_localctx, 54, RULE_func4);
|
|
try {
|
|
setState(1384);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SWAP:
|
|
_localctx = new SwapFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1329);
|
|
match(SWAP);
|
|
setState(1330);
|
|
match(LPAREN);
|
|
setState(1331);
|
|
expr();
|
|
setState(1332);
|
|
match(COMMA);
|
|
setState(1333);
|
|
expr();
|
|
setState(1334);
|
|
match(COMMA);
|
|
setState(1335);
|
|
expr();
|
|
setState(1336);
|
|
match(COMMA);
|
|
setState(1337);
|
|
expr();
|
|
setState(1338);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case NVL:
|
|
_localctx = new NvlFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1340);
|
|
match(NVL);
|
|
setState(1341);
|
|
match(LPAREN);
|
|
setState(1342);
|
|
expr();
|
|
setState(1343);
|
|
match(COMMA);
|
|
setState(1344);
|
|
expr();
|
|
setState(1345);
|
|
match(COMMA);
|
|
setState(1346);
|
|
expr();
|
|
setState(1347);
|
|
match(COMMA);
|
|
setState(1348);
|
|
expr();
|
|
setState(1349);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LOGSPACE:
|
|
_localctx = new LogspaceFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1351);
|
|
match(LOGSPACE);
|
|
setState(1352);
|
|
match(LPAREN);
|
|
setState(1353);
|
|
expr();
|
|
setState(1354);
|
|
match(COMMA);
|
|
setState(1355);
|
|
expr();
|
|
setState(1356);
|
|
match(COMMA);
|
|
setState(1357);
|
|
expr();
|
|
setState(1358);
|
|
match(COMMA);
|
|
setState(1359);
|
|
expr();
|
|
setState(1360);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case DIST:
|
|
_localctx = new DistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1362);
|
|
match(DIST);
|
|
setState(1363);
|
|
match(LPAREN);
|
|
setState(1364);
|
|
expr();
|
|
setState(1365);
|
|
match(COMMA);
|
|
setState(1366);
|
|
expr();
|
|
setState(1367);
|
|
match(COMMA);
|
|
setState(1368);
|
|
expr();
|
|
setState(1369);
|
|
match(COMMA);
|
|
setState(1370);
|
|
expr();
|
|
setState(1371);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case HISTOGRAM:
|
|
_localctx = new HistogramFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1373);
|
|
match(HISTOGRAM);
|
|
setState(1374);
|
|
match(LPAREN);
|
|
setState(1375);
|
|
expr();
|
|
setState(1376);
|
|
match(COMMA);
|
|
setState(1377);
|
|
expr();
|
|
setState(1378);
|
|
match(COMMA);
|
|
setState(1379);
|
|
expr();
|
|
setState(1380);
|
|
match(COMMA);
|
|
setState(1381);
|
|
expr();
|
|
setState(1382);
|
|
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 Func5Context extends ParserRuleContext {
|
|
public Func5Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_func5; }
|
|
|
|
public Func5Context() { }
|
|
public void copyFrom(Func5Context ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RemapFuncContext extends Func5Context {
|
|
public TerminalNode REMAP() { return getToken(MathExprParser.REMAP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public RemapFuncContext(Func5Context ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRemapFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRemapFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRemapFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Func5Context func5() throws RecognitionException {
|
|
Func5Context _localctx = new Func5Context(_ctx, getState());
|
|
enterRule(_localctx, 56, RULE_func5);
|
|
try {
|
|
_localctx = new RemapFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1386);
|
|
match(REMAP);
|
|
setState(1387);
|
|
match(LPAREN);
|
|
setState(1388);
|
|
expr();
|
|
setState(1389);
|
|
match(COMMA);
|
|
setState(1390);
|
|
expr();
|
|
setState(1391);
|
|
match(COMMA);
|
|
setState(1392);
|
|
expr();
|
|
setState(1393);
|
|
match(COMMA);
|
|
setState(1394);
|
|
expr();
|
|
setState(1395);
|
|
match(COMMA);
|
|
setState(1396);
|
|
expr();
|
|
setState(1397);
|
|
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 FuncNContext extends ParserRuleContext {
|
|
public FuncNContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_funcN; }
|
|
|
|
public FuncNContext() { }
|
|
public void copyFrom(FuncNContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SMaxFuncContext extends FuncNContext {
|
|
public TerminalNode SMAX() { return getToken(MathExprParser.SMAX, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public SMaxFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSMaxFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSMaxFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSMaxFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MapFuncContext extends FuncNContext {
|
|
public TerminalNode MAP() { return getToken(MathExprParser.MAP, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public MapFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterMapFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitMapFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitMapFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConcatFuncContext extends FuncNContext {
|
|
public TerminalNode CONCAT() { return getToken(MathExprParser.CONCAT, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public ConcatFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterConcatFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitConcatFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitConcatFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EzConvFuncContext extends FuncNContext {
|
|
public TerminalNode EZCONV() { return getToken(MathExprParser.EZCONV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public EzConvFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterEzConvFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitEzConvFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitEzConvFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReshapeFuncContext extends FuncNContext {
|
|
public TerminalNode RESHAPE() { return getToken(MathExprParser.RESHAPE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ReshapeFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterReshapeFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitReshapeFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitReshapeFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SMinFuncContext extends FuncNContext {
|
|
public TerminalNode SMIN() { return getToken(MathExprParser.SMIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public SMinFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterSMinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitSMinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitSMinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConvFuncContext extends FuncNContext {
|
|
public TerminalNode CONV() { return getToken(MathExprParser.CONV, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public ConvFuncContext(FuncNContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterConvFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitConvFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitConvFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FuncNContext funcN() throws RecognitionException {
|
|
FuncNContext _localctx = new FuncNContext(_ctx, getState());
|
|
enterRule(_localctx, 58, RULE_funcN);
|
|
int _la;
|
|
try {
|
|
setState(1474);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SMIN:
|
|
_localctx = new SMinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1399);
|
|
match(SMIN);
|
|
setState(1400);
|
|
match(LPAREN);
|
|
setState(1401);
|
|
expr();
|
|
setState(1406);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1402);
|
|
match(COMMA);
|
|
setState(1403);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1408);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1409);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SMAX:
|
|
_localctx = new SMaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1411);
|
|
match(SMAX);
|
|
setState(1412);
|
|
match(LPAREN);
|
|
setState(1413);
|
|
expr();
|
|
setState(1418);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1414);
|
|
match(COMMA);
|
|
setState(1415);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1420);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1421);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MAP:
|
|
_localctx = new MapFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1423);
|
|
match(MAP);
|
|
setState(1424);
|
|
match(LPAREN);
|
|
setState(1425);
|
|
expr();
|
|
setState(1428);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1426);
|
|
match(COMMA);
|
|
setState(1427);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1430);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(1432);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EZCONV:
|
|
_localctx = new EzConvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1434);
|
|
match(EZCONV);
|
|
setState(1435);
|
|
match(LPAREN);
|
|
setState(1436);
|
|
expr();
|
|
setState(1439);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1437);
|
|
match(COMMA);
|
|
setState(1438);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1441);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(1443);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CONV:
|
|
_localctx = new ConvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1445);
|
|
match(CONV);
|
|
setState(1446);
|
|
match(LPAREN);
|
|
setState(1447);
|
|
expr();
|
|
setState(1450);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1448);
|
|
match(COMMA);
|
|
setState(1449);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1452);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(1454);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RESHAPE:
|
|
_localctx = new ReshapeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1456);
|
|
match(RESHAPE);
|
|
setState(1457);
|
|
match(LPAREN);
|
|
setState(1458);
|
|
expr();
|
|
setState(1459);
|
|
match(COMMA);
|
|
setState(1460);
|
|
expr();
|
|
setState(1461);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CONCAT:
|
|
_localctx = new ConcatFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1463);
|
|
match(CONCAT);
|
|
setState(1464);
|
|
match(LPAREN);
|
|
setState(1465);
|
|
expr();
|
|
setState(1468);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1466);
|
|
match(COMMA);
|
|
setState(1467);
|
|
expr();
|
|
}
|
|
}
|
|
setState(1470);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(1472);
|
|
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 FuncNoiseContext extends ParserRuleContext {
|
|
public FuncNoiseContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_funcNoise; }
|
|
|
|
public FuncNoiseContext() { }
|
|
public void copyFrom(FuncNoiseContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExponentialFuncContext extends FuncNoiseContext {
|
|
public TerminalNode EXPONENTIAL() { return getToken(MathExprParser.EXPONENTIAL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public ExponentialFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterExponentialFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitExponentialFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitExponentialFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PoissonFuncContext extends FuncNoiseContext {
|
|
public TerminalNode POISSON() { return getToken(MathExprParser.POISSON, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PoissonFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPoissonFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPoissonFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPoissonFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LaplaceDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode LAPLACEDIST() { return getToken(MathExprParser.LAPLACEDIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LaplaceDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLaplaceDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLaplaceDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLaplaceDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CellularFuncContext extends FuncNoiseContext {
|
|
public TerminalNode CELLULAR() { return getToken(MathExprParser.CELLULAR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CellularFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCellularFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCellularFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCellularFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NoiseFuncContext extends FuncNoiseContext {
|
|
public TerminalNode NOISE() { return getToken(MathExprParser.NOISE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public NoiseFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterNoiseFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitNoiseFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitNoiseFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BetaDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode BETADIST() { return getToken(MathExprParser.BETADIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BetaDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBetaDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBetaDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBetaDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BernoulliFuncContext extends FuncNoiseContext {
|
|
public TerminalNode BERNOULLI() { return getToken(MathExprParser.BERNOULLI, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public BernoulliFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterBernoulliFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitBernoulliFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitBernoulliFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GammaDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode GAMMADIST() { return getToken(MathExprParser.GAMMADIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GammaDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGammaDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGammaDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGammaDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WeibullDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode WEIBULLDIST() { return getToken(MathExprParser.WEIBULLDIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public WeibullDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterWeibullDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitWeibullDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitWeibullDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LogNormalFuncContext extends FuncNoiseContext {
|
|
public TerminalNode LOGNORMAL() { return getToken(MathExprParser.LOGNORMAL, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public LogNormalFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterLogNormalFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitLogNormalFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitLogNormalFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PerlinFuncContext extends FuncNoiseContext {
|
|
public TerminalNode PERLIN() { return getToken(MathExprParser.PERLIN, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PerlinFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPerlinFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPerlinFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPerlinFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PlasmaFuncContext extends FuncNoiseContext {
|
|
public TerminalNode PLASMA() { return getToken(MathExprParser.PLASMA, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public PlasmaFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterPlasmaFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitPlasmaFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitPlasmaFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GumbelDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode GUMBELDIST() { return getToken(MathExprParser.GUMBELDIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public GumbelDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterGumbelDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitGumbelDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitGumbelDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CauchyFuncContext extends FuncNoiseContext {
|
|
public TerminalNode CAUCHY() { return getToken(MathExprParser.CAUCHY, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public CauchyFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterCauchyFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitCauchyFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitCauchyFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StudentTDistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode STUDENTTDIST() { return getToken(MathExprParser.STUDENTTDIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public StudentTDistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterStudentTDistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitStudentTDistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitStudentTDistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Chi2DistFuncContext extends FuncNoiseContext {
|
|
public TerminalNode CHI2DIST() { return getToken(MathExprParser.CHI2DIST, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(MathExprParser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(MathExprParser.COMMA, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public Chi2DistFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterChi2DistFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitChi2DistFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitChi2DistFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RandFuncContext extends FuncNoiseContext {
|
|
public TerminalNode RAND() { return getToken(MathExprParser.RAND, 0); }
|
|
public TerminalNode LPAREN() { return getToken(MathExprParser.LPAREN, 0); }
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(MathExprParser.RPAREN, 0); }
|
|
public TerminalNode COMMA() { return getToken(MathExprParser.COMMA, 0); }
|
|
public RandFuncContext(FuncNoiseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).enterRandFunc(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof MathExprListener ) ((MathExprListener)listener).exitRandFunc(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof MathExprVisitor ) return ((MathExprVisitor<? extends T>)visitor).visitRandFunc(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FuncNoiseContext funcNoise() throws RecognitionException {
|
|
FuncNoiseContext _localctx = new FuncNoiseContext(_ctx, getState());
|
|
enterRule(_localctx, 60, RULE_funcNoise);
|
|
int _la;
|
|
try {
|
|
setState(1697);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case NOISE:
|
|
_localctx = new NoiseFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1476);
|
|
match(NOISE);
|
|
setState(1477);
|
|
match(LPAREN);
|
|
setState(1478);
|
|
expr();
|
|
setState(1481);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1479);
|
|
match(COMMA);
|
|
setState(1480);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1483);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RAND:
|
|
_localctx = new RandFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1485);
|
|
match(RAND);
|
|
setState(1486);
|
|
match(LPAREN);
|
|
setState(1487);
|
|
expr();
|
|
setState(1490);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1488);
|
|
match(COMMA);
|
|
setState(1489);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1492);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EXPONENTIAL:
|
|
_localctx = new ExponentialFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1494);
|
|
match(EXPONENTIAL);
|
|
setState(1495);
|
|
match(LPAREN);
|
|
setState(1496);
|
|
expr();
|
|
setState(1497);
|
|
match(COMMA);
|
|
setState(1498);
|
|
expr();
|
|
setState(1501);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1499);
|
|
match(COMMA);
|
|
setState(1500);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1503);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BERNOULLI:
|
|
_localctx = new BernoulliFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1505);
|
|
match(BERNOULLI);
|
|
setState(1506);
|
|
match(LPAREN);
|
|
setState(1507);
|
|
expr();
|
|
setState(1508);
|
|
match(COMMA);
|
|
setState(1509);
|
|
expr();
|
|
setState(1512);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1510);
|
|
match(COMMA);
|
|
setState(1511);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1514);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case POISSON:
|
|
_localctx = new PoissonFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1516);
|
|
match(POISSON);
|
|
setState(1517);
|
|
match(LPAREN);
|
|
setState(1518);
|
|
expr();
|
|
setState(1519);
|
|
match(COMMA);
|
|
setState(1520);
|
|
expr();
|
|
setState(1523);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1521);
|
|
match(COMMA);
|
|
setState(1522);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1525);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CAUCHY:
|
|
_localctx = new CauchyFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1527);
|
|
match(CAUCHY);
|
|
setState(1528);
|
|
match(LPAREN);
|
|
setState(1529);
|
|
expr();
|
|
setState(1530);
|
|
match(COMMA);
|
|
setState(1531);
|
|
expr();
|
|
setState(1532);
|
|
match(COMMA);
|
|
setState(1533);
|
|
expr();
|
|
setState(1536);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1534);
|
|
match(COMMA);
|
|
setState(1535);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1538);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LOGNORMAL:
|
|
_localctx = new LogNormalFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1540);
|
|
match(LOGNORMAL);
|
|
setState(1541);
|
|
match(LPAREN);
|
|
setState(1542);
|
|
expr();
|
|
setState(1543);
|
|
match(COMMA);
|
|
setState(1544);
|
|
expr();
|
|
setState(1545);
|
|
match(COMMA);
|
|
setState(1546);
|
|
expr();
|
|
setState(1549);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1547);
|
|
match(COMMA);
|
|
setState(1548);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1551);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GAMMADIST:
|
|
_localctx = new GammaDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1553);
|
|
match(GAMMADIST);
|
|
setState(1554);
|
|
match(LPAREN);
|
|
setState(1555);
|
|
expr();
|
|
setState(1556);
|
|
match(COMMA);
|
|
setState(1557);
|
|
expr();
|
|
setState(1558);
|
|
match(COMMA);
|
|
setState(1559);
|
|
expr();
|
|
setState(1562);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1560);
|
|
match(COMMA);
|
|
setState(1561);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1564);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case BETADIST:
|
|
_localctx = new BetaDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1566);
|
|
match(BETADIST);
|
|
setState(1567);
|
|
match(LPAREN);
|
|
setState(1568);
|
|
expr();
|
|
setState(1569);
|
|
match(COMMA);
|
|
setState(1570);
|
|
expr();
|
|
setState(1571);
|
|
match(COMMA);
|
|
setState(1572);
|
|
expr();
|
|
setState(1575);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1573);
|
|
match(COMMA);
|
|
setState(1574);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1577);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LAPLACEDIST:
|
|
_localctx = new LaplaceDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1579);
|
|
match(LAPLACEDIST);
|
|
setState(1580);
|
|
match(LPAREN);
|
|
setState(1581);
|
|
expr();
|
|
setState(1582);
|
|
match(COMMA);
|
|
setState(1583);
|
|
expr();
|
|
setState(1584);
|
|
match(COMMA);
|
|
setState(1585);
|
|
expr();
|
|
setState(1588);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1586);
|
|
match(COMMA);
|
|
setState(1587);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1590);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GUMBELDIST:
|
|
_localctx = new GumbelDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1592);
|
|
match(GUMBELDIST);
|
|
setState(1593);
|
|
match(LPAREN);
|
|
setState(1594);
|
|
expr();
|
|
setState(1595);
|
|
match(COMMA);
|
|
setState(1596);
|
|
expr();
|
|
setState(1597);
|
|
match(COMMA);
|
|
setState(1598);
|
|
expr();
|
|
setState(1601);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1599);
|
|
match(COMMA);
|
|
setState(1600);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1603);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case WEIBULLDIST:
|
|
_localctx = new WeibullDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(1605);
|
|
match(WEIBULLDIST);
|
|
setState(1606);
|
|
match(LPAREN);
|
|
setState(1607);
|
|
expr();
|
|
setState(1608);
|
|
match(COMMA);
|
|
setState(1609);
|
|
expr();
|
|
setState(1610);
|
|
match(COMMA);
|
|
setState(1611);
|
|
expr();
|
|
setState(1614);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1612);
|
|
match(COMMA);
|
|
setState(1613);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1616);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CHI2DIST:
|
|
_localctx = new Chi2DistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(1618);
|
|
match(CHI2DIST);
|
|
setState(1619);
|
|
match(LPAREN);
|
|
setState(1620);
|
|
expr();
|
|
setState(1621);
|
|
match(COMMA);
|
|
setState(1622);
|
|
expr();
|
|
setState(1625);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1623);
|
|
match(COMMA);
|
|
setState(1624);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1627);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case STUDENTTDIST:
|
|
_localctx = new StudentTDistFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(1629);
|
|
match(STUDENTTDIST);
|
|
setState(1630);
|
|
match(LPAREN);
|
|
setState(1631);
|
|
expr();
|
|
setState(1632);
|
|
match(COMMA);
|
|
setState(1633);
|
|
expr();
|
|
setState(1636);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1634);
|
|
match(COMMA);
|
|
setState(1635);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1638);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PERLIN:
|
|
_localctx = new PerlinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(1640);
|
|
match(PERLIN);
|
|
setState(1641);
|
|
match(LPAREN);
|
|
setState(1642);
|
|
expr();
|
|
setState(1643);
|
|
match(COMMA);
|
|
setState(1644);
|
|
expr();
|
|
setState(1647);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1645);
|
|
match(COMMA);
|
|
setState(1646);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1651);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1649);
|
|
match(COMMA);
|
|
setState(1650);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1655);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1653);
|
|
match(COMMA);
|
|
setState(1654);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1657);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CELLULAR:
|
|
_localctx = new CellularFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(1659);
|
|
match(CELLULAR);
|
|
setState(1660);
|
|
match(LPAREN);
|
|
setState(1661);
|
|
expr();
|
|
setState(1662);
|
|
match(COMMA);
|
|
setState(1663);
|
|
expr();
|
|
setState(1666);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1664);
|
|
match(COMMA);
|
|
setState(1665);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1670);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1668);
|
|
match(COMMA);
|
|
setState(1669);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1674);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1672);
|
|
match(COMMA);
|
|
setState(1673);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1676);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PLASMA:
|
|
_localctx = new PlasmaFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(1678);
|
|
match(PLASMA);
|
|
setState(1679);
|
|
match(LPAREN);
|
|
setState(1680);
|
|
expr();
|
|
setState(1681);
|
|
match(COMMA);
|
|
setState(1682);
|
|
expr();
|
|
setState(1685);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1683);
|
|
match(COMMA);
|
|
setState(1684);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1689);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1687);
|
|
match(COMMA);
|
|
setState(1688);
|
|
expr();
|
|
}
|
|
break;
|
|
}
|
|
setState(1693);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1691);
|
|
match(COMMA);
|
|
setState(1692);
|
|
expr();
|
|
}
|
|
}
|
|
|
|
setState(1695);
|
|
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;
|
|
}
|
|
|
|
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
|
|
switch (ruleIndex) {
|
|
case 14:
|
|
return compExpr_sempred((CompExprContext)_localctx, predIndex);
|
|
case 15:
|
|
return addExpr_sempred((AddExprContext)_localctx, predIndex);
|
|
case 16:
|
|
return mulExpr_sempred((MulExprContext)_localctx, predIndex);
|
|
case 17:
|
|
return shiftExpr_sempred((ShiftExprContext)_localctx, predIndex);
|
|
case 20:
|
|
return indexExpr_sempred((IndexExprContext)_localctx, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean compExpr_sempred(CompExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 0:
|
|
return precpred(_ctx, 7);
|
|
case 1:
|
|
return precpred(_ctx, 6);
|
|
case 2:
|
|
return precpred(_ctx, 5);
|
|
case 3:
|
|
return precpred(_ctx, 4);
|
|
case 4:
|
|
return precpred(_ctx, 3);
|
|
case 5:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean addExpr_sempred(AddExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 6:
|
|
return precpred(_ctx, 3);
|
|
case 7:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean mulExpr_sempred(MulExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 8:
|
|
return precpred(_ctx, 4);
|
|
case 9:
|
|
return precpred(_ctx, 3);
|
|
case 10:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean shiftExpr_sempred(ShiftExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 11:
|
|
return precpred(_ctx, 3);
|
|
case 12:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean indexExpr_sempred(IndexExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 13:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final String _serializedATN =
|
|
"\u0004\u0001\u00dc\u06a4\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\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000B\b\u0000\n\u0000"+
|
|
"\f\u0000E\t\u0000\u0001\u0000\u0001\u0000\u0003\u0000I\b\u0000\u0001\u0000"+
|
|
"\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001P\b\u0001"+
|
|
"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001V\b\u0001"+
|
|
"\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
|
|
"\u0001\u0002\u0005\u0002_\b\u0002\n\u0002\f\u0002b\t\u0002\u0001\u0002"+
|
|
"\u0001\u0002\u0005\u0002f\b\u0002\n\u0002\f\u0002i\t\u0002\u0001\u0002"+
|
|
"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003"+
|
|
"\u0005\u0003r\b\u0003\n\u0003\f\u0003u\t\u0003\u0001\u0004\u0001\u0004"+
|
|
"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
|
|
"\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0082\b\u0004\u0001\u0005"+
|
|
"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+
|
|
"\u0003\u0005\u008b\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
|
|
"\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
|
|
"\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0005"+
|
|
"\b\u009d\b\b\n\b\f\b\u00a0\t\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t"+
|
|
"\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0003\u000b\u00ac\b\u000b"+
|
|
"\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0003\f\u00b3\b\f\u0001"+
|
|
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001"+
|
|
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
|
|
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
|
|
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
|
|
"\u000e\u0005\u000e\u00d0\b\u000e\n\u000e\f\u000e\u00d3\t\u000e\u0001\u000f"+
|
|
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
|
|
"\u0001\u000f\u0001\u000f\u0005\u000f\u00de\b\u000f\n\u000f\f\u000f\u00e1"+
|
|
"\t\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+
|
|
"\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+
|
|
"\u0010\u0005\u0010\u00ef\b\u0010\n\u0010\f\u0010\u00f2\t\u0010\u0001\u0011"+
|
|
"\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+
|
|
"\u0001\u0011\u0001\u0011\u0005\u0011\u00fd\b\u0011\n\u0011\f\u0011\u0100"+
|
|
"\t\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003"+
|
|
"\u0012\u0107\b\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
|
|
"\u0013\u0003\u0013\u010e\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
|
|
"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u0118"+
|
|
"\b\u0014\n\u0014\f\u0014\u011b\t\u0014\u0001\u0014\u0001\u0014\u0005\u0014"+
|
|
"\u011f\b\u0014\n\u0014\f\u0014\u0122\t\u0014\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u013c\b\u0015\n"+
|
|
"\u0015\f\u0015\u013f\t\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0003\u0015\u0146\b\u0015\u0001\u0015\u0001\u0015\u0001"+
|
|
"\u0015\u0001\u0015\u0003\u0015\u014c\b\u0015\u0001\u0016\u0001\u0016\u0001"+
|
|
"\u0016\u0005\u0016\u0151\b\u0016\n\u0016\f\u0016\u0154\t\u0016\u0001\u0017"+
|
|
"\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u0227\b\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u025d\b\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018"+
|
|
"\u0270\b\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0003\u0018\u0279\b\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u02c8\b\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0003\u0018\u02d1\b\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u02da\b\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0003\u0018\u02e3\b\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
|
|
"\u0003\u0018\u02fb\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0003\u0019\u037b\b\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0003\u0019\u03a9\b\u0019\u0003\u0019\u03ab\b\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
|
|
"\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u03d6\b\u0019\u0003"+
|
|
"\u0019\u03d8\b\u0019\u0003\u0019\u03da\b\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0003\u0019\u03f8\b\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019"+
|
|
"\u0401\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u040c\b\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u0417\b\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0003\u0019\u0438\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0003\u0019\u0451\b\u0019\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0003\u001a\u04b2\b\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u04bf\b\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a"+
|
|
"\u04d3\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a"+
|
|
"\u04df\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a"+
|
|
"\u04eb\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
|
|
"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a"+
|
|
"\u04f7\b\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u04fb\b\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0507\b\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0003\u001a\u050b\b\u001a\u0001\u001a\u0001\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0520"+
|
|
"\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u052c"+
|
|
"\b\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0530\b\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\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\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\u0569\b\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+
|
|
"\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+
|
|
"\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d"+
|
|
"\u0001\u001d\u0001\u001d\u0005\u001d\u057d\b\u001d\n\u001d\f\u001d\u0580"+
|
|
"\t\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
|
|
"\u001d\u0001\u001d\u0005\u001d\u0589\b\u001d\n\u001d\f\u001d\u058c\t\u001d"+
|
|
"\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+
|
|
"\u0001\u001d\u0004\u001d\u0595\b\u001d\u000b\u001d\f\u001d\u0596\u0001"+
|
|
"\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
|
|
"\u001d\u0004\u001d\u05a0\b\u001d\u000b\u001d\f\u001d\u05a1\u0001\u001d"+
|
|
"\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+
|
|
"\u0004\u001d\u05ab\b\u001d\u000b\u001d\f\u001d\u05ac\u0001\u001d\u0001"+
|
|
"\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
|
|
"\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
|
|
"\u001d\u0004\u001d\u05bd\b\u001d\u000b\u001d\f\u001d\u05be\u0001\u001d"+
|
|
"\u0001\u001d\u0003\u001d\u05c3\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0003\u001e\u05ca\b\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e"+
|
|
"\u05d3\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u05de\b\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u05e9\b\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0003\u001e\u05f4\b\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0601\b\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u060e\b\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e"+
|
|
"\u061b\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0003\u001e\u0628\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0003\u001e\u0635\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0003\u001e\u0642\b\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u064f\b\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0003\u001e\u065a\b\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0003\u001e\u0665\b\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0003\u001e\u0670\b\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0674\b"+
|
|
"\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0678\b\u001e\u0001\u001e\u0001"+
|
|
"\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+
|
|
"\u001e\u0001\u001e\u0003\u001e\u0683\b\u001e\u0001\u001e\u0001\u001e\u0003"+
|
|
"\u001e\u0687\b\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u068b\b\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0696\b\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0003\u001e\u069a\b\u001e\u0001\u001e\u0001\u001e\u0003\u001e"+
|
|
"\u069e\b\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u06a2\b\u001e\u0001"+
|
|
"\u001e\u0000\u0005\u001c\u001e \"(\u001f\u0000\u0002\u0004\u0006\b\n\f"+
|
|
"\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:"+
|
|
"<\u0000\u0001\u0001\u0000\u00c3\u00c8\u07a0\u0000C\u0001\u0000\u0000\u0000"+
|
|
"\u0002L\u0001\u0000\u0000\u0000\u0004Y\u0001\u0000\u0000\u0000\u0006n"+
|
|
"\u0001\u0000\u0000\u0000\b\u0081\u0001\u0000\u0000\u0000\n\u0083\u0001"+
|
|
"\u0000\u0000\u0000\f\u008c\u0001\u0000\u0000\u0000\u000e\u0092\u0001\u0000"+
|
|
"\u0000\u0000\u0010\u009a\u0001\u0000\u0000\u0000\u0012\u00a3\u0001\u0000"+
|
|
"\u0000\u0000\u0014\u00a6\u0001\u0000\u0000\u0000\u0016\u00a9\u0001\u0000"+
|
|
"\u0000\u0000\u0018\u00b2\u0001\u0000\u0000\u0000\u001a\u00b4\u0001\u0000"+
|
|
"\u0000\u0000\u001c\u00ba\u0001\u0000\u0000\u0000\u001e\u00d4\u0001\u0000"+
|
|
"\u0000\u0000 \u00e2\u0001\u0000\u0000\u0000\"\u00f3\u0001\u0000\u0000"+
|
|
"\u0000$\u0106\u0001\u0000\u0000\u0000&\u010d\u0001\u0000\u0000\u0000("+
|
|
"\u010f\u0001\u0000\u0000\u0000*\u014b\u0001\u0000\u0000\u0000,\u014d\u0001"+
|
|
"\u0000\u0000\u0000.\u0155\u0001\u0000\u0000\u00000\u02fa\u0001\u0000\u0000"+
|
|
"\u00002\u0450\u0001\u0000\u0000\u00004\u052f\u0001\u0000\u0000\u00006"+
|
|
"\u0568\u0001\u0000\u0000\u00008\u056a\u0001\u0000\u0000\u0000:\u05c2\u0001"+
|
|
"\u0000\u0000\u0000<\u06a1\u0001\u0000\u0000\u0000>B\u0003\u0002\u0001"+
|
|
"\u0000?B\u0003\u0004\u0002\u0000@B\u0003\b\u0004\u0000A>\u0001\u0000\u0000"+
|
|
"\u0000A?\u0001\u0000\u0000\u0000A@\u0001\u0000\u0000\u0000BE\u0001\u0000"+
|
|
"\u0000\u0000CA\u0001\u0000\u0000\u0000CD\u0001\u0000\u0000\u0000DF\u0001"+
|
|
"\u0000\u0000\u0000EC\u0001\u0000\u0000\u0000FH\u0003\u0018\f\u0000GI\u0005"+
|
|
"\u00ce\u0000\u0000HG\u0001\u0000\u0000\u0000HI\u0001\u0000\u0000\u0000"+
|
|
"IJ\u0001\u0000\u0000\u0000JK\u0005\u0000\u0000\u0001K\u0001\u0001\u0000"+
|
|
"\u0000\u0000LM\u0005\u00d9\u0000\u0000MO\u0005\u00cb\u0000\u0000NP\u0003"+
|
|
"\u0006\u0003\u0000ON\u0001\u0000\u0000\u0000OP\u0001\u0000\u0000\u0000"+
|
|
"PQ\u0001\u0000\u0000\u0000QR\u0005\u00cc\u0000\u0000RU\u0005\u00cf\u0000"+
|
|
"\u0000SV\u0003\u0010\b\u0000TV\u0003\u0018\f\u0000US\u0001\u0000\u0000"+
|
|
"\u0000UT\u0001\u0000\u0000\u0000VW\u0001\u0000\u0000\u0000WX\u0005\u00ce"+
|
|
"\u0000\u0000X\u0003\u0001\u0000\u0000\u0000Yg\u0005\u00d9\u0000\u0000"+
|
|
"Z[\u0005\u00d0\u0000\u0000[`\u0003\u0018\f\u0000\\]\u0005\u00cd\u0000"+
|
|
"\u0000]_\u0003\u0018\f\u0000^\\\u0001\u0000\u0000\u0000_b\u0001\u0000"+
|
|
"\u0000\u0000`^\u0001\u0000\u0000\u0000`a\u0001\u0000\u0000\u0000ac\u0001"+
|
|
"\u0000\u0000\u0000b`\u0001\u0000\u0000\u0000cd\u0005\u00d1\u0000\u0000"+
|
|
"df\u0001\u0000\u0000\u0000eZ\u0001\u0000\u0000\u0000fi\u0001\u0000\u0000"+
|
|
"\u0000ge\u0001\u0000\u0000\u0000gh\u0001\u0000\u0000\u0000hj\u0001\u0000"+
|
|
"\u0000\u0000ig\u0001\u0000\u0000\u0000jk\u0007\u0000\u0000\u0000kl\u0003"+
|
|
"\u0018\f\u0000lm\u0005\u00ce\u0000\u0000m\u0005\u0001\u0000\u0000\u0000"+
|
|
"ns\u0005\u00d9\u0000\u0000op\u0005\u00cd\u0000\u0000pr\u0005\u00d9\u0000"+
|
|
"\u0000qo\u0001\u0000\u0000\u0000ru\u0001\u0000\u0000\u0000sq\u0001\u0000"+
|
|
"\u0000\u0000st\u0001\u0000\u0000\u0000t\u0007\u0001\u0000\u0000\u0000"+
|
|
"us\u0001\u0000\u0000\u0000v\u0082\u0003\n\u0005\u0000w\u0082\u0003\f\u0006"+
|
|
"\u0000x\u0082\u0003\u0010\b\u0000y\u0082\u0003\u0012\t\u0000z\u0082\u0003"+
|
|
"\u0014\n\u0000{\u0082\u0003\u0016\u000b\u0000|\u0082\u0003\u0004\u0002"+
|
|
"\u0000}\u0082\u0003\u000e\u0007\u0000~\u007f\u0003\u0018\f\u0000\u007f"+
|
|
"\u0080\u0005\u00ce\u0000\u0000\u0080\u0082\u0001\u0000\u0000\u0000\u0081"+
|
|
"v\u0001\u0000\u0000\u0000\u0081w\u0001\u0000\u0000\u0000\u0081x\u0001"+
|
|
"\u0000\u0000\u0000\u0081y\u0001\u0000\u0000\u0000\u0081z\u0001\u0000\u0000"+
|
|
"\u0000\u0081{\u0001\u0000\u0000\u0000\u0081|\u0001\u0000\u0000\u0000\u0081"+
|
|
"}\u0001\u0000\u0000\u0000\u0081~\u0001\u0000\u0000\u0000\u0082\t\u0001"+
|
|
"\u0000\u0000\u0000\u0083\u0084\u0005\u008e\u0000\u0000\u0084\u0085\u0005"+
|
|
"\u00cb\u0000\u0000\u0085\u0086\u0003\u0018\f\u0000\u0086\u0087\u0005\u00cc"+
|
|
"\u0000\u0000\u0087\u008a\u0003\b\u0004\u0000\u0088\u0089\u0005\u008f\u0000"+
|
|
"\u0000\u0089\u008b\u0003\b\u0004\u0000\u008a\u0088\u0001\u0000\u0000\u0000"+
|
|
"\u008a\u008b\u0001\u0000\u0000\u0000\u008b\u000b\u0001\u0000\u0000\u0000"+
|
|
"\u008c\u008d\u0005\u0090\u0000\u0000\u008d\u008e\u0005\u00cb\u0000\u0000"+
|
|
"\u008e\u008f\u0003\u0018\f\u0000\u008f\u0090\u0005\u00cc\u0000\u0000\u0090"+
|
|
"\u0091\u0003\b\u0004\u0000\u0091\r\u0001\u0000\u0000\u0000\u0092\u0093"+
|
|
"\u0005\u0091\u0000\u0000\u0093\u0094\u0005\u00cb\u0000\u0000\u0094\u0095"+
|
|
"\u0005\u00d9\u0000\u0000\u0095\u0096\u0005\u0092\u0000\u0000\u0096\u0097"+
|
|
"\u0003\u0018\f\u0000\u0097\u0098\u0005\u00cc\u0000\u0000\u0098\u0099\u0003"+
|
|
"\b\u0004\u0000\u0099\u000f\u0001\u0000\u0000\u0000\u009a\u009e\u0005\u00d4"+
|
|
"\u0000\u0000\u009b\u009d\u0003\b\u0004\u0000\u009c\u009b\u0001\u0000\u0000"+
|
|
"\u0000\u009d\u00a0\u0001\u0000\u0000\u0000\u009e\u009c\u0001\u0000\u0000"+
|
|
"\u0000\u009e\u009f\u0001\u0000\u0000\u0000\u009f\u00a1\u0001\u0000\u0000"+
|
|
"\u0000\u00a0\u009e\u0001\u0000\u0000\u0000\u00a1\u00a2\u0005\u00d5\u0000"+
|
|
"\u0000\u00a2\u0011\u0001\u0000\u0000\u0000\u00a3\u00a4\u0005\u0093\u0000"+
|
|
"\u0000\u00a4\u00a5\u0005\u00ce\u0000\u0000\u00a5\u0013\u0001\u0000\u0000"+
|
|
"\u0000\u00a6\u00a7\u0005\u0094\u0000\u0000\u00a7\u00a8\u0005\u00ce\u0000"+
|
|
"\u0000\u00a8\u0015\u0001\u0000\u0000\u0000\u00a9\u00ab\u0005\u0095\u0000"+
|
|
"\u0000\u00aa\u00ac\u0003\u0018\f\u0000\u00ab\u00aa\u0001\u0000\u0000\u0000"+
|
|
"\u00ab\u00ac\u0001\u0000\u0000\u0000\u00ac\u00ad\u0001\u0000\u0000\u0000"+
|
|
"\u00ad\u00ae\u0005\u00ce\u0000\u0000\u00ae\u0017\u0001\u0000\u0000\u0000"+
|
|
"\u00af\u00b3\u0003\u001a\r\u0000\u00b0\u00b3\u0003*\u0015\u0000\u00b1"+
|
|
"\u00b3\u0003\u001c\u000e\u0000\u00b2\u00af\u0001\u0000\u0000\u0000\u00b2"+
|
|
"\u00b0\u0001\u0000\u0000\u0000\u00b2\u00b1\u0001\u0000\u0000\u0000\u00b3"+
|
|
"\u0019\u0001\u0000\u0000\u0000\u00b4\u00b5\u0003\u001c\u000e\u0000\u00b5"+
|
|
"\u00b6\u0005\u00d2\u0000\u0000\u00b6\u00b7\u0003\u0018\f\u0000\u00b7\u00b8"+
|
|
"\u0005\u00d3\u0000\u0000\u00b8\u00b9\u0003\u0018\f\u0000\u00b9\u001b\u0001"+
|
|
"\u0000\u0000\u0000\u00ba\u00bb\u0006\u000e\uffff\uffff\u0000\u00bb\u00bc"+
|
|
"\u0003\u001e\u000f\u0000\u00bc\u00d1\u0001\u0000\u0000\u0000\u00bd\u00be"+
|
|
"\n\u0007\u0000\u0000\u00be\u00bf\u0005\u00bf\u0000\u0000\u00bf\u00d0\u0003"+
|
|
"\u001e\u000f\u0000\u00c0\u00c1\n\u0006\u0000\u0000\u00c1\u00c2\u0005\u00be"+
|
|
"\u0000\u0000\u00c2\u00d0\u0003\u001e\u000f\u0000\u00c3\u00c4\n\u0005\u0000"+
|
|
"\u0000\u00c4\u00c5\u0005\u00c1\u0000\u0000\u00c5\u00d0\u0003\u001e\u000f"+
|
|
"\u0000\u00c6\u00c7\n\u0004\u0000\u0000\u00c7\u00c8\u0005\u00c0\u0000\u0000"+
|
|
"\u00c8\u00d0\u0003\u001e\u000f\u0000\u00c9\u00ca\n\u0003\u0000\u0000\u00ca"+
|
|
"\u00cb\u0005\u00c2\u0000\u0000\u00cb\u00d0\u0003\u001e\u000f\u0000\u00cc"+
|
|
"\u00cd\n\u0002\u0000\u0000\u00cd\u00ce\u0005\u00c9\u0000\u0000\u00ce\u00d0"+
|
|
"\u0003\u001e\u000f\u0000\u00cf\u00bd\u0001\u0000\u0000\u0000\u00cf\u00c0"+
|
|
"\u0001\u0000\u0000\u0000\u00cf\u00c3\u0001\u0000\u0000\u0000\u00cf\u00c6"+
|
|
"\u0001\u0000\u0000\u0000\u00cf\u00c9\u0001\u0000\u0000\u0000\u00cf\u00cc"+
|
|
"\u0001\u0000\u0000\u0000\u00d0\u00d3\u0001\u0000\u0000\u0000\u00d1\u00cf"+
|
|
"\u0001\u0000\u0000\u0000\u00d1\u00d2\u0001\u0000\u0000\u0000\u00d2\u001d"+
|
|
"\u0001\u0000\u0000\u0000\u00d3\u00d1\u0001\u0000\u0000\u0000\u00d4\u00d5"+
|
|
"\u0006\u000f\uffff\uffff\u0000\u00d5\u00d6\u0003 \u0010\u0000\u00d6\u00df"+
|
|
"\u0001\u0000\u0000\u0000\u00d7\u00d8\n\u0003\u0000\u0000\u00d8\u00d9\u0005"+
|
|
"\u00b6\u0000\u0000\u00d9\u00de\u0003 \u0010\u0000\u00da\u00db\n\u0002"+
|
|
"\u0000\u0000\u00db\u00dc\u0005\u00b7\u0000\u0000\u00dc\u00de\u0003 \u0010"+
|
|
"\u0000\u00dd\u00d7\u0001\u0000\u0000\u0000\u00dd\u00da\u0001\u0000\u0000"+
|
|
"\u0000\u00de\u00e1\u0001\u0000\u0000\u0000\u00df\u00dd\u0001\u0000\u0000"+
|
|
"\u0000\u00df\u00e0\u0001\u0000\u0000\u0000\u00e0\u001f\u0001\u0000\u0000"+
|
|
"\u0000\u00e1\u00df\u0001\u0000\u0000\u0000\u00e2\u00e3\u0006\u0010\uffff"+
|
|
"\uffff\u0000\u00e3\u00e4\u0003\"\u0011\u0000\u00e4\u00f0\u0001\u0000\u0000"+
|
|
"\u0000\u00e5\u00e6\n\u0004\u0000\u0000\u00e6\u00e7\u0005\u00b8\u0000\u0000"+
|
|
"\u00e7\u00ef\u0003\"\u0011\u0000\u00e8\u00e9\n\u0003\u0000\u0000\u00e9"+
|
|
"\u00ea\u0005\u00b9\u0000\u0000\u00ea\u00ef\u0003\"\u0011\u0000\u00eb\u00ec"+
|
|
"\n\u0002\u0000\u0000\u00ec\u00ed\u0005\u00ba\u0000\u0000\u00ed\u00ef\u0003"+
|
|
"\"\u0011\u0000\u00ee\u00e5\u0001\u0000\u0000\u0000\u00ee\u00e8\u0001\u0000"+
|
|
"\u0000\u0000\u00ee\u00eb\u0001\u0000\u0000\u0000\u00ef\u00f2\u0001\u0000"+
|
|
"\u0000\u0000\u00f0\u00ee\u0001\u0000\u0000\u0000\u00f0\u00f1\u0001\u0000"+
|
|
"\u0000\u0000\u00f1!\u0001\u0000\u0000\u0000\u00f2\u00f0\u0001\u0000\u0000"+
|
|
"\u0000\u00f3\u00f4\u0006\u0011\uffff\uffff\u0000\u00f4\u00f5\u0003$\u0012"+
|
|
"\u0000\u00f5\u00fe\u0001\u0000\u0000\u0000\u00f6\u00f7\n\u0003\u0000\u0000"+
|
|
"\u00f7\u00f8\u0005\u00bc\u0000\u0000\u00f8\u00fd\u0003$\u0012\u0000\u00f9"+
|
|
"\u00fa\n\u0002\u0000\u0000\u00fa\u00fb\u0005\u00bd\u0000\u0000\u00fb\u00fd"+
|
|
"\u0003$\u0012\u0000\u00fc\u00f6\u0001\u0000\u0000\u0000\u00fc\u00f9\u0001"+
|
|
"\u0000\u0000\u0000\u00fd\u0100\u0001\u0000\u0000\u0000\u00fe\u00fc\u0001"+
|
|
"\u0000\u0000\u0000\u00fe\u00ff\u0001\u0000\u0000\u0000\u00ff#\u0001\u0000"+
|
|
"\u0000\u0000\u0100\u00fe\u0001\u0000\u0000\u0000\u0101\u0102\u0003&\u0013"+
|
|
"\u0000\u0102\u0103\u0005\u00bb\u0000\u0000\u0103\u0104\u0003$\u0012\u0000"+
|
|
"\u0104\u0107\u0001\u0000\u0000\u0000\u0105\u0107\u0003&\u0013\u0000\u0106"+
|
|
"\u0101\u0001\u0000\u0000\u0000\u0106\u0105\u0001\u0000\u0000\u0000\u0107"+
|
|
"%\u0001\u0000\u0000\u0000\u0108\u0109\u0005\u00b6\u0000\u0000\u0109\u010e"+
|
|
"\u0003&\u0013\u0000\u010a\u010b\u0005\u00b7\u0000\u0000\u010b\u010e\u0003"+
|
|
"&\u0013\u0000\u010c\u010e\u0003(\u0014\u0000\u010d\u0108\u0001\u0000\u0000"+
|
|
"\u0000\u010d\u010a\u0001\u0000\u0000\u0000\u010d\u010c\u0001\u0000\u0000"+
|
|
"\u0000\u010e\'\u0001\u0000\u0000\u0000\u010f\u0110\u0006\u0014\uffff\uffff"+
|
|
"\u0000\u0110\u0111\u0003*\u0015\u0000\u0111\u0120\u0001\u0000\u0000\u0000"+
|
|
"\u0112\u0113\n\u0002\u0000\u0000\u0113\u0114\u0005\u00d0\u0000\u0000\u0114"+
|
|
"\u0119\u0003\u0018\f\u0000\u0115\u0116\u0005\u00cd\u0000\u0000\u0116\u0118"+
|
|
"\u0003\u0018\f\u0000\u0117\u0115\u0001\u0000\u0000\u0000\u0118\u011b\u0001"+
|
|
"\u0000\u0000\u0000\u0119\u0117\u0001\u0000\u0000\u0000\u0119\u011a\u0001"+
|
|
"\u0000\u0000\u0000\u011a\u011c\u0001\u0000\u0000\u0000\u011b\u0119\u0001"+
|
|
"\u0000\u0000\u0000\u011c\u011d\u0005\u00d1\u0000\u0000\u011d\u011f\u0001"+
|
|
"\u0000\u0000\u0000\u011e\u0112\u0001\u0000\u0000\u0000\u011f\u0122\u0001"+
|
|
"\u0000\u0000\u0000\u0120\u011e\u0001\u0000\u0000\u0000\u0120\u0121\u0001"+
|
|
"\u0000\u0000\u0000\u0121)\u0001\u0000\u0000\u0000\u0122\u0120\u0001\u0000"+
|
|
"\u0000\u0000\u0123\u014c\u0003.\u0017\u0000\u0124\u014c\u00030\u0018\u0000"+
|
|
"\u0125\u014c\u00032\u0019\u0000\u0126\u014c\u00034\u001a\u0000\u0127\u014c"+
|
|
"\u00036\u001b\u0000\u0128\u014c\u00038\u001c\u0000\u0129\u014c\u0003:"+
|
|
"\u001d\u0000\u012a\u014c\u0003<\u001e\u0000\u012b\u014c\u0005\u00d9\u0000"+
|
|
"\u0000\u012c\u014c\u0005\u00d6\u0000\u0000\u012d\u014c\u0005\u00d7\u0000"+
|
|
"\u0000\u012e\u014c\u0005\u00d8\u0000\u0000\u012f\u0130\u0005\u00cb\u0000"+
|
|
"\u0000\u0130\u0131\u0003\u0018\f\u0000\u0131\u0132\u0005\u00cc\u0000\u0000"+
|
|
"\u0132\u014c\u0001\u0000\u0000\u0000\u0133\u0134\u0005\u00ca\u0000\u0000"+
|
|
"\u0134\u0135\u0003\u0018\f\u0000\u0135\u0136\u0005\u00ca\u0000\u0000\u0136"+
|
|
"\u014c\u0001\u0000\u0000\u0000\u0137\u0138\u0005\u00d0\u0000\u0000\u0138"+
|
|
"\u013d\u0003\u0018\f\u0000\u0139\u013a\u0005\u00cd\u0000\u0000\u013a\u013c"+
|
|
"\u0003\u0018\f\u0000\u013b\u0139\u0001\u0000\u0000\u0000\u013c\u013f\u0001"+
|
|
"\u0000\u0000\u0000\u013d\u013b\u0001\u0000\u0000\u0000\u013d\u013e\u0001"+
|
|
"\u0000\u0000\u0000\u013e\u0140\u0001\u0000\u0000\u0000\u013f\u013d\u0001"+
|
|
"\u0000\u0000\u0000\u0140\u0141\u0005\u00d1\u0000\u0000\u0141\u014c\u0001"+
|
|
"\u0000\u0000\u0000\u0142\u0143\u0005\u00d9\u0000\u0000\u0143\u0145\u0005"+
|
|
"\u00cb\u0000\u0000\u0144\u0146\u0003,\u0016\u0000\u0145\u0144\u0001\u0000"+
|
|
"\u0000\u0000\u0145\u0146\u0001\u0000\u0000\u0000\u0146\u0147\u0001\u0000"+
|
|
"\u0000\u0000\u0147\u014c\u0005\u00cc\u0000\u0000\u0148\u014c\u0005\u00a4"+
|
|
"\u0000\u0000\u0149\u014c\u0005\u0093\u0000\u0000\u014a\u014c\u0005\u0094"+
|
|
"\u0000\u0000\u014b\u0123\u0001\u0000\u0000\u0000\u014b\u0124\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u0125\u0001\u0000\u0000\u0000\u014b\u0126\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u0127\u0001\u0000\u0000\u0000\u014b\u0128\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u0129\u0001\u0000\u0000\u0000\u014b\u012a\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u012b\u0001\u0000\u0000\u0000\u014b\u012c\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u012d\u0001\u0000\u0000\u0000\u014b\u012e\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u012f\u0001\u0000\u0000\u0000\u014b\u0133\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u0137\u0001\u0000\u0000\u0000\u014b\u0142\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u0148\u0001\u0000\u0000\u0000\u014b\u0149\u0001\u0000"+
|
|
"\u0000\u0000\u014b\u014a\u0001\u0000\u0000\u0000\u014c+\u0001\u0000\u0000"+
|
|
"\u0000\u014d\u0152\u0003\u0018\f\u0000\u014e\u014f\u0005\u00cd\u0000\u0000"+
|
|
"\u014f\u0151\u0003\u0018\f\u0000\u0150\u014e\u0001\u0000\u0000\u0000\u0151"+
|
|
"\u0154\u0001\u0000\u0000\u0000\u0152\u0150\u0001\u0000\u0000\u0000\u0152"+
|
|
"\u0153\u0001\u0000\u0000\u0000\u0153-\u0001\u0000\u0000\u0000\u0154\u0152"+
|
|
"\u0001\u0000\u0000\u0000\u0155\u0156\u0005\u0096\u0000\u0000\u0156\u0157"+
|
|
"\u0005\u00cb\u0000\u0000\u0157\u0158\u0005\u00cc\u0000\u0000\u0158/\u0001"+
|
|
"\u0000\u0000\u0000\u0159\u015a\u0005\u0001\u0000\u0000\u015a\u015b\u0005"+
|
|
"\u00cb\u0000\u0000\u015b\u015c\u0003\u0018\f\u0000\u015c\u015d\u0005\u00cc"+
|
|
"\u0000\u0000\u015d\u02fb\u0001\u0000\u0000\u0000\u015e\u015f\u0005\u0002"+
|
|
"\u0000\u0000\u015f\u0160\u0005\u00cb\u0000\u0000\u0160\u0161\u0003\u0018"+
|
|
"\f\u0000\u0161\u0162\u0005\u00cc\u0000\u0000\u0162\u02fb\u0001\u0000\u0000"+
|
|
"\u0000\u0163\u0164\u0005\u0003\u0000\u0000\u0164\u0165\u0005\u00cb\u0000"+
|
|
"\u0000\u0165\u0166\u0003\u0018\f\u0000\u0166\u0167\u0005\u00cc\u0000\u0000"+
|
|
"\u0167\u02fb\u0001\u0000\u0000\u0000\u0168\u0169\u0005\u0004\u0000\u0000"+
|
|
"\u0169\u016a\u0005\u00cb\u0000\u0000\u016a\u016b\u0003\u0018\f\u0000\u016b"+
|
|
"\u016c\u0005\u00cc\u0000\u0000\u016c\u02fb\u0001\u0000\u0000\u0000\u016d"+
|
|
"\u016e\u0005\u0005\u0000\u0000\u016e\u016f\u0005\u00cb\u0000\u0000\u016f"+
|
|
"\u0170\u0003\u0018\f\u0000\u0170\u0171\u0005\u00cc\u0000\u0000\u0171\u02fb"+
|
|
"\u0001\u0000\u0000\u0000\u0172\u0173\u0005\u0006\u0000\u0000\u0173\u0174"+
|
|
"\u0005\u00cb\u0000\u0000\u0174\u0175\u0003\u0018\f\u0000\u0175\u0176\u0005"+
|
|
"\u00cc\u0000\u0000\u0176\u02fb\u0001\u0000\u0000\u0000\u0177\u0178\u0005"+
|
|
"\b\u0000\u0000\u0178\u0179\u0005\u00cb\u0000\u0000\u0179\u017a\u0003\u0018"+
|
|
"\f\u0000\u017a\u017b\u0005\u00cc\u0000\u0000\u017b\u02fb\u0001\u0000\u0000"+
|
|
"\u0000\u017c\u017d\u0005\t\u0000\u0000\u017d\u017e\u0005\u00cb\u0000\u0000"+
|
|
"\u017e\u017f\u0003\u0018\f\u0000\u017f\u0180\u0005\u00cc\u0000\u0000\u0180"+
|
|
"\u02fb\u0001\u0000\u0000\u0000\u0181\u0182\u0005\n\u0000\u0000\u0182\u0183"+
|
|
"\u0005\u00cb\u0000\u0000\u0183\u0184\u0003\u0018\f\u0000\u0184\u0185\u0005"+
|
|
"\u00cc\u0000\u0000\u0185\u02fb\u0001\u0000\u0000\u0000\u0186\u0187\u0005"+
|
|
"\u000b\u0000\u0000\u0187\u0188\u0005\u00cb\u0000\u0000\u0188\u0189\u0003"+
|
|
"\u0018\f\u0000\u0189\u018a\u0005\u00cc\u0000\u0000\u018a\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u018b\u018c\u0005\f\u0000\u0000\u018c\u018d\u0005\u00cb\u0000"+
|
|
"\u0000\u018d\u018e\u0003\u0018\f\u0000\u018e\u018f\u0005\u00cc\u0000\u0000"+
|
|
"\u018f\u02fb\u0001\u0000\u0000\u0000\u0190\u0191\u0005\r\u0000\u0000\u0191"+
|
|
"\u0192\u0005\u00cb\u0000\u0000\u0192\u0193\u0003\u0018\f\u0000\u0193\u0194"+
|
|
"\u0005\u00cc\u0000\u0000\u0194\u02fb\u0001\u0000\u0000\u0000\u0195\u0196"+
|
|
"\u0005\u000e\u0000\u0000\u0196\u0197\u0005\u00cb\u0000\u0000\u0197\u0198"+
|
|
"\u0003\u0018\f\u0000\u0198\u0199\u0005\u00cc\u0000\u0000\u0199\u02fb\u0001"+
|
|
"\u0000\u0000\u0000\u019a\u019b\u0005\u000f\u0000\u0000\u019b\u019c\u0005"+
|
|
"\u00cb\u0000\u0000\u019c\u019d\u0003\u0018\f\u0000\u019d\u019e\u0005\u00cc"+
|
|
"\u0000\u0000\u019e\u02fb\u0001\u0000\u0000\u0000\u019f\u01a0\u0005\u0010"+
|
|
"\u0000\u0000\u01a0\u01a1\u0005\u00cb\u0000\u0000\u01a1\u01a2\u0003\u0018"+
|
|
"\f\u0000\u01a2\u01a3\u0005\u00cc\u0000\u0000\u01a3\u02fb\u0001\u0000\u0000"+
|
|
"\u0000\u01a4\u01a5\u0005\u0011\u0000\u0000\u01a5\u01a6\u0005\u00cb\u0000"+
|
|
"\u0000\u01a6\u01a7\u0003\u0018\f\u0000\u01a7\u01a8\u0005\u00cc\u0000\u0000"+
|
|
"\u01a8\u02fb\u0001\u0000\u0000\u0000\u01a9\u01aa\u0005\u0012\u0000\u0000"+
|
|
"\u01aa\u01ab\u0005\u00cb\u0000\u0000\u01ab\u01ac\u0003\u0018\f\u0000\u01ac"+
|
|
"\u01ad\u0005\u00cc\u0000\u0000\u01ad\u02fb\u0001\u0000\u0000\u0000\u01ae"+
|
|
"\u01af\u0005\u0017\u0000\u0000\u01af\u01b0\u0005\u00cb\u0000\u0000\u01b0"+
|
|
"\u01b1\u0003\u0018\f\u0000\u01b1\u01b2\u0005\u00cc\u0000\u0000\u01b2\u02fb"+
|
|
"\u0001\u0000\u0000\u0000\u01b3\u01b4\u0005\u0018\u0000\u0000\u01b4\u01b5"+
|
|
"\u0005\u00cb\u0000\u0000\u01b5\u01b6\u0003\u0018\f\u0000\u01b6\u01b7\u0005"+
|
|
"\u00cc\u0000\u0000\u01b7\u02fb\u0001\u0000\u0000\u0000\u01b8\u01b9\u0005"+
|
|
"\u0019\u0000\u0000\u01b9\u01ba\u0005\u00cb\u0000\u0000\u01ba\u01bb\u0003"+
|
|
"\u0018\f\u0000\u01bb\u01bc\u0005\u00cc\u0000\u0000\u01bc\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u01bd\u01be\u0005\u001a\u0000\u0000\u01be\u01bf\u0005\u00cb"+
|
|
"\u0000\u0000\u01bf\u01c0\u0003\u0018\f\u0000\u01c0\u01c1\u0005\u00cc\u0000"+
|
|
"\u0000\u01c1\u02fb\u0001\u0000\u0000\u0000\u01c2\u01c3\u0005\u001b\u0000"+
|
|
"\u0000\u01c3\u01c4\u0005\u00cb\u0000\u0000\u01c4\u01c5\u0003\u0018\f\u0000"+
|
|
"\u01c5\u01c6\u0005\u00cc\u0000\u0000\u01c6\u02fb\u0001\u0000\u0000\u0000"+
|
|
"\u01c7\u01c8\u0005\u001c\u0000\u0000\u01c8\u01c9\u0005\u00cb\u0000\u0000"+
|
|
"\u01c9\u01ca\u0003\u0018\f\u0000\u01ca\u01cb\u0005\u00cc\u0000\u0000\u01cb"+
|
|
"\u02fb\u0001\u0000\u0000\u0000\u01cc\u01cd\u0005\u001e\u0000\u0000\u01cd"+
|
|
"\u01ce\u0005\u00cb\u0000\u0000\u01ce\u01cf\u0003\u0018\f\u0000\u01cf\u01d0"+
|
|
"\u0005\u00cc\u0000\u0000\u01d0\u02fb\u0001\u0000\u0000\u0000\u01d1\u01d2"+
|
|
"\u0005\"\u0000\u0000\u01d2\u01d3\u0005\u00cb\u0000\u0000\u01d3\u01d4\u0003"+
|
|
"\u0018\f\u0000\u01d4\u01d5\u0005\u00cc\u0000\u0000\u01d5\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u01d6\u01d7\u0005#\u0000\u0000\u01d7\u01d8\u0005\u00cb\u0000"+
|
|
"\u0000\u01d8\u01d9\u0003\u0018\f\u0000\u01d9\u01da\u0005\u00cc\u0000\u0000"+
|
|
"\u01da\u02fb\u0001\u0000\u0000\u0000\u01db\u01dc\u0005)\u0000\u0000\u01dc"+
|
|
"\u01dd\u0005\u00cb\u0000\u0000\u01dd\u01de\u0003\u0018\f\u0000\u01de\u01df"+
|
|
"\u0005\u00cc\u0000\u0000\u01df\u02fb\u0001\u0000\u0000\u0000\u01e0\u01e1"+
|
|
"\u0005*\u0000\u0000\u01e1\u01e2\u0005\u00cb\u0000\u0000\u01e2\u01e3\u0003"+
|
|
"\u0018\f\u0000\u01e3\u01e4\u0005\u00cc\u0000\u0000\u01e4\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u01e5\u01e6\u0005+\u0000\u0000\u01e6\u01e7\u0005\u00cb\u0000"+
|
|
"\u0000\u01e7\u01e8\u0003\u0018\f\u0000\u01e8\u01e9\u0005\u00cc\u0000\u0000"+
|
|
"\u01e9\u02fb\u0001\u0000\u0000\u0000\u01ea\u01eb\u0005,\u0000\u0000\u01eb"+
|
|
"\u01ec\u0005\u00cb\u0000\u0000\u01ec\u01ed\u0003\u0018\f\u0000\u01ed\u01ee"+
|
|
"\u0005\u00cc\u0000\u0000\u01ee\u02fb\u0001\u0000\u0000\u0000\u01ef\u01f0"+
|
|
"\u0005-\u0000\u0000\u01f0\u01f1\u0005\u00cb\u0000\u0000\u01f1\u01f2\u0003"+
|
|
"\u0018\f\u0000\u01f2\u01f3\u0005\u00cc\u0000\u0000\u01f3\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u01f4\u01f5\u0005$\u0000\u0000\u01f5\u01f6\u0005\u00cb\u0000"+
|
|
"\u0000\u01f6\u01f7\u0003\u0018\f\u0000\u01f7\u01f8\u0005\u00cc\u0000\u0000"+
|
|
"\u01f8\u02fb\u0001\u0000\u0000\u0000\u01f9\u01fa\u00059\u0000\u0000\u01fa"+
|
|
"\u01fb\u0005\u00cb\u0000\u0000\u01fb\u01fc\u0003\u0018\f\u0000\u01fc\u01fd"+
|
|
"\u0005\u00cc\u0000\u0000\u01fd\u02fb\u0001\u0000\u0000\u0000\u01fe\u01ff"+
|
|
"\u0005:\u0000\u0000\u01ff\u0200\u0005\u00cb\u0000\u0000\u0200\u0201\u0003"+
|
|
"\u0018\f\u0000\u0201\u0202\u0005\u00cc\u0000\u0000\u0202\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u0203\u0204\u0005;\u0000\u0000\u0204\u0205\u0005\u00cb\u0000"+
|
|
"\u0000\u0205\u0206\u0003\u0018\f\u0000\u0206\u0207\u0005\u00cc\u0000\u0000"+
|
|
"\u0207\u02fb\u0001\u0000\u0000\u0000\u0208\u0209\u0005<\u0000\u0000\u0209"+
|
|
"\u020a\u0005\u00cb\u0000\u0000\u020a\u020b\u0003\u0018\f\u0000\u020b\u020c"+
|
|
"\u0005\u00cc\u0000\u0000\u020c\u02fb\u0001\u0000\u0000\u0000\u020d\u020e"+
|
|
"\u0005=\u0000\u0000\u020e\u020f\u0005\u00cb\u0000\u0000\u020f\u0210\u0003"+
|
|
"\u0018\f\u0000\u0210\u0211\u0005\u00cc\u0000\u0000\u0211\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u0212\u0213\u0005\u0097\u0000\u0000\u0213\u0214\u0005\u00cb"+
|
|
"\u0000\u0000\u0214\u0215\u0003\u0018\f\u0000\u0215\u0216\u0005\u00cc\u0000"+
|
|
"\u0000\u0216\u02fb\u0001\u0000\u0000\u0000\u0217\u0218\u0005E\u0000\u0000"+
|
|
"\u0218\u0219\u0005\u00cb\u0000\u0000\u0219\u021a\u0003\u0018\f\u0000\u021a"+
|
|
"\u021b\u0005\u00cc\u0000\u0000\u021b\u02fb\u0001\u0000\u0000\u0000\u021c"+
|
|
"\u021d\u0005F\u0000\u0000\u021d\u021e\u0005\u00cb\u0000\u0000\u021e\u021f"+
|
|
"\u0003\u0018\f\u0000\u021f\u0220\u0005\u00cc\u0000\u0000\u0220\u02fb\u0001"+
|
|
"\u0000\u0000\u0000\u0221\u0222\u0005G\u0000\u0000\u0222\u0223\u0005\u00cb"+
|
|
"\u0000\u0000\u0223\u0226\u0003\u0018\f\u0000\u0224\u0225\u0005\u00cd\u0000"+
|
|
"\u0000\u0225\u0227\u0003\u0018\f\u0000\u0226\u0224\u0001\u0000\u0000\u0000"+
|
|
"\u0226\u0227\u0001\u0000\u0000\u0000\u0227\u0228\u0001\u0000\u0000\u0000"+
|
|
"\u0228\u0229\u0005\u00cc\u0000\u0000\u0229\u02fb\u0001\u0000\u0000\u0000"+
|
|
"\u022a\u022b\u0005I\u0000\u0000\u022b\u022c\u0005\u00cb\u0000\u0000\u022c"+
|
|
"\u022d\u0003\u0018\f\u0000\u022d\u022e\u0005\u00cc\u0000\u0000\u022e\u02fb"+
|
|
"\u0001\u0000\u0000\u0000\u022f\u0230\u0005J\u0000\u0000\u0230\u0231\u0005"+
|
|
"\u00cb\u0000\u0000\u0231\u0232\u0003\u0018\f\u0000\u0232\u0233\u0005\u00cc"+
|
|
"\u0000\u0000\u0233\u02fb\u0001\u0000\u0000\u0000\u0234\u0235\u0005K\u0000"+
|
|
"\u0000\u0235\u0236\u0005\u00cb\u0000\u0000\u0236\u0237\u0003\u0018\f\u0000"+
|
|
"\u0237\u0238\u0005\u00cc\u0000\u0000\u0238\u02fb\u0001\u0000\u0000\u0000"+
|
|
"\u0239\u023a\u0005V\u0000\u0000\u023a\u023b\u0005\u00cb\u0000\u0000\u023b"+
|
|
"\u023c\u0003\u0018\f\u0000\u023c\u023d\u0005\u00cc\u0000\u0000\u023d\u02fb"+
|
|
"\u0001\u0000\u0000\u0000\u023e\u023f\u0005L\u0000\u0000\u023f\u0240\u0005"+
|
|
"\u00cb\u0000\u0000\u0240\u0241\u0003\u0018\f\u0000\u0241\u0242\u0005\u00cc"+
|
|
"\u0000\u0000\u0242\u02fb\u0001\u0000\u0000\u0000\u0243\u0244\u0005o\u0000"+
|
|
"\u0000\u0244\u0245\u0005\u00cb\u0000\u0000\u0245\u0246\u0003\u0018\f\u0000"+
|
|
"\u0246\u0247\u0005\u00cc\u0000\u0000\u0247\u02fb\u0001\u0000\u0000\u0000"+
|
|
"\u0248\u0249\u0005p\u0000\u0000\u0249\u024a\u0005\u00cb\u0000\u0000\u024a"+
|
|
"\u024b\u0003\u0018\f\u0000\u024b\u024c\u0005\u00cc\u0000\u0000\u024c\u02fb"+
|
|
"\u0001\u0000\u0000\u0000\u024d\u024e\u0005q\u0000\u0000\u024e\u024f\u0005"+
|
|
"\u00cb\u0000\u0000\u024f\u0250\u0003\u0018\f\u0000\u0250\u0251\u0005\u00cc"+
|
|
"\u0000\u0000\u0251\u02fb\u0001\u0000\u0000\u0000\u0252\u0253\u0005r\u0000"+
|
|
"\u0000\u0253\u0254\u0005\u00cb\u0000\u0000\u0254\u0255\u0003\u0018\f\u0000"+
|
|
"\u0255\u0256\u0005\u00cc\u0000\u0000\u0256\u02fb\u0001\u0000\u0000\u0000"+
|
|
"\u0257\u0258\u0005\u0098\u0000\u0000\u0258\u0259\u0005\u00cb\u0000\u0000"+
|
|
"\u0259\u025c\u0003\u0018\f\u0000\u025a\u025b\u0005\u00cd\u0000\u0000\u025b"+
|
|
"\u025d\u0003\u0018\f\u0000\u025c\u025a\u0001\u0000\u0000\u0000\u025c\u025d"+
|
|
"\u0001\u0000\u0000\u0000\u025d\u025e\u0001\u0000\u0000\u0000\u025e\u025f"+
|
|
"\u0005\u00cc\u0000\u0000\u025f\u02fb\u0001\u0000\u0000\u0000\u0260\u0261"+
|
|
"\u0005\u0099\u0000\u0000\u0261\u0262\u0005\u00cb\u0000\u0000\u0262\u0263"+
|
|
"\u0003\u0018\f\u0000\u0263\u0264\u0005\u00cc\u0000\u0000\u0264\u02fb\u0001"+
|
|
"\u0000\u0000\u0000\u0265\u0266\u0005\u009a\u0000\u0000\u0266\u0267\u0005"+
|
|
"\u00cb\u0000\u0000\u0267\u0268\u0003\u0018\f\u0000\u0268\u0269\u0005\u00cc"+
|
|
"\u0000\u0000\u0269\u02fb\u0001\u0000\u0000\u0000\u026a\u026b\u0005\u009b"+
|
|
"\u0000\u0000\u026b\u026c\u0005\u00cb\u0000\u0000\u026c\u026f\u0003\u0018"+
|
|
"\f\u0000\u026d\u026e\u0005\u00cd\u0000\u0000\u026e\u0270\u0003\u0018\f"+
|
|
"\u0000\u026f\u026d\u0001\u0000\u0000\u0000\u026f\u0270\u0001\u0000\u0000"+
|
|
"\u0000\u0270\u0271\u0001\u0000\u0000\u0000\u0271\u0272\u0005\u00cc\u0000"+
|
|
"\u0000\u0272\u02fb\u0001\u0000\u0000\u0000\u0273\u0274\u0005\u009c\u0000"+
|
|
"\u0000\u0274\u0275\u0005\u00cb\u0000\u0000\u0275\u0278\u0003\u0018\f\u0000"+
|
|
"\u0276\u0277\u0005\u00cd\u0000\u0000\u0277\u0279\u0003\u0018\f\u0000\u0278"+
|
|
"\u0276\u0001\u0000\u0000\u0000\u0278\u0279\u0001\u0000\u0000\u0000\u0279"+
|
|
"\u027a\u0001\u0000\u0000\u0000\u027a\u027b\u0005\u00cc\u0000\u0000\u027b"+
|
|
"\u02fb\u0001\u0000\u0000\u0000\u027c\u027d\u0005C\u0000\u0000\u027d\u027e"+
|
|
"\u0005\u00cb\u0000\u0000\u027e\u027f\u0003\u0018\f\u0000\u027f\u0280\u0005"+
|
|
"\u00cc\u0000\u0000\u0280\u02fb\u0001\u0000\u0000\u0000\u0281\u0282\u0005"+
|
|
"D\u0000\u0000\u0282\u0283\u0005\u00cb\u0000\u0000\u0283\u0284\u0003\u0018"+
|
|
"\f\u0000\u0284\u0285\u0005\u00cc\u0000\u0000\u0285\u02fb\u0001\u0000\u0000"+
|
|
"\u0000\u0286\u0287\u0005\u009d\u0000\u0000\u0287\u0288\u0005\u00cb\u0000"+
|
|
"\u0000\u0288\u0289\u0003\u0018\f\u0000\u0289\u028a\u0005\u00cc\u0000\u0000"+
|
|
"\u028a\u02fb\u0001\u0000\u0000\u0000\u028b\u028c\u0005W\u0000\u0000\u028c"+
|
|
"\u028d\u0005\u00cb\u0000\u0000\u028d\u028e\u0003\u0018\f\u0000\u028e\u028f"+
|
|
"\u0005\u00cc\u0000\u0000\u028f\u02fb\u0001\u0000\u0000\u0000\u0290\u0291"+
|
|
"\u0005\\\u0000\u0000\u0291\u0292\u0005\u00cb\u0000\u0000\u0292\u0293\u0003"+
|
|
"\u0018\f\u0000\u0293\u0294\u0005\u00cc\u0000\u0000\u0294\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u0295\u0296\u0005]\u0000\u0000\u0296\u0297\u0005\u00cb\u0000"+
|
|
"\u0000\u0297\u0298\u0003\u0018\f\u0000\u0298\u0299\u0005\u00cc\u0000\u0000"+
|
|
"\u0299\u02fb\u0001\u0000\u0000\u0000\u029a\u029b\u0005g\u0000\u0000\u029b"+
|
|
"\u029c\u0005\u00cb\u0000\u0000\u029c\u029d\u0003\u0018\f\u0000\u029d\u029e"+
|
|
"\u0005\u00cc\u0000\u0000\u029e\u02fb\u0001\u0000\u0000\u0000\u029f\u02a0"+
|
|
"\u0005h\u0000\u0000\u02a0\u02a1\u0005\u00cb\u0000\u0000\u02a1\u02a2\u0003"+
|
|
"\u0018\f\u0000\u02a2\u02a3\u0005\u00cc\u0000\u0000\u02a3\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u02a4\u02a5\u0005i\u0000\u0000\u02a5\u02a6\u0005\u00cb\u0000"+
|
|
"\u0000\u02a6\u02a7\u0003\u0018\f\u0000\u02a7\u02a8\u0005\u00cc\u0000\u0000"+
|
|
"\u02a8\u02fb\u0001\u0000\u0000\u0000\u02a9\u02aa\u0005v\u0000\u0000\u02aa"+
|
|
"\u02ab\u0005\u00cb\u0000\u0000\u02ab\u02ac\u0003\u0018\f\u0000\u02ac\u02ad"+
|
|
"\u0005\u00cc\u0000\u0000\u02ad\u02fb\u0001\u0000\u0000\u0000\u02ae\u02af"+
|
|
"\u0005w\u0000\u0000\u02af\u02b0\u0005\u00cb\u0000\u0000\u02b0\u02b1\u0003"+
|
|
"\u0018\f\u0000\u02b1\u02b2\u0005\u00cc\u0000\u0000\u02b2\u02fb\u0001\u0000"+
|
|
"\u0000\u0000\u02b3\u02b4\u0005x\u0000\u0000\u02b4\u02b5\u0005\u00cb\u0000"+
|
|
"\u0000\u02b5\u02b6\u0003\u0018\f\u0000\u02b6\u02b7\u0005\u00cc\u0000\u0000"+
|
|
"\u02b7\u02fb\u0001\u0000\u0000\u0000\u02b8\u02b9\u0005\u00a2\u0000\u0000"+
|
|
"\u02b9\u02ba\u0005\u00cb\u0000\u0000\u02ba\u02bb\u0003\u0018\f\u0000\u02bb"+
|
|
"\u02bc\u0005\u00cc\u0000\u0000\u02bc\u02fb\u0001\u0000\u0000\u0000\u02bd"+
|
|
"\u02be\u0005 \u0000\u0000\u02be\u02bf\u0005\u00cb\u0000\u0000\u02bf\u02c0"+
|
|
"\u0003\u0018\f\u0000\u02c0\u02c1\u0005\u00cc\u0000\u0000\u02c1\u02fb\u0001"+
|
|
"\u0000\u0000\u0000\u02c2\u02c3\u0005\u007f\u0000\u0000\u02c3\u02c4\u0005"+
|
|
"\u00cb\u0000\u0000\u02c4\u02c7\u0003\u0018\f\u0000\u02c5\u02c6\u0005\u00cd"+
|
|
"\u0000\u0000\u02c6\u02c8\u0003\u0018\f\u0000\u02c7\u02c5\u0001\u0000\u0000"+
|
|
"\u0000\u02c7\u02c8\u0001\u0000\u0000\u0000\u02c8\u02c9\u0001\u0000\u0000"+
|
|
"\u0000\u02c9\u02ca\u0005\u00cc\u0000\u0000\u02ca\u02fb\u0001\u0000\u0000"+
|
|
"\u0000\u02cb\u02cc\u0005\u0080\u0000\u0000\u02cc\u02cd\u0005\u00cb\u0000"+
|
|
"\u0000\u02cd\u02d0\u0003\u0018\f\u0000\u02ce\u02cf\u0005\u00cd\u0000\u0000"+
|
|
"\u02cf\u02d1\u0003\u0018\f\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000\u02d0"+
|
|
"\u02d1\u0001\u0000\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000\u02d2"+
|
|
"\u02d3\u0005\u00cc\u0000\u0000\u02d3\u02fb\u0001\u0000\u0000\u0000\u02d4"+
|
|
"\u02d5\u0005\u0081\u0000\u0000\u02d5\u02d6\u0005\u00cb\u0000\u0000\u02d6"+
|
|
"\u02d9\u0003\u0018\f\u0000\u02d7\u02d8\u0005\u00cd\u0000\u0000\u02d8\u02da"+
|
|
"\u0003\u0018\f\u0000\u02d9\u02d7\u0001\u0000\u0000\u0000\u02d9\u02da\u0001"+
|
|
"\u0000\u0000\u0000\u02da\u02db\u0001\u0000\u0000\u0000\u02db\u02dc\u0005"+
|
|
"\u00cc\u0000\u0000\u02dc\u02fb\u0001\u0000\u0000\u0000\u02dd\u02de\u0005"+
|
|
"\u0082\u0000\u0000\u02de\u02df\u0005\u00cb\u0000\u0000\u02df\u02e2\u0003"+
|
|
"\u0018\f\u0000\u02e0\u02e1\u0005\u00cd\u0000\u0000\u02e1\u02e3\u0003\u0018"+
|
|
"\f\u0000\u02e2\u02e0\u0001\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000"+
|
|
"\u0000\u02e3\u02e4\u0001\u0000\u0000\u0000\u02e4\u02e5\u0005\u00cc\u0000"+
|
|
"\u0000\u02e5\u02fb\u0001\u0000\u0000\u0000\u02e6\u02e7\u0005t\u0000\u0000"+
|
|
"\u02e7\u02e8\u0005\u00cb\u0000\u0000\u02e8\u02e9\u0003\u0018\f\u0000\u02e9"+
|
|
"\u02ea\u0005\u00cc\u0000\u0000\u02ea\u02fb\u0001\u0000\u0000\u0000\u02eb"+
|
|
"\u02ec\u0005u\u0000\u0000\u02ec\u02ed\u0005\u00cb\u0000\u0000\u02ed\u02ee"+
|
|
"\u0003\u0018\f\u0000\u02ee\u02ef\u0005\u00cc\u0000\u0000\u02ef\u02fb\u0001"+
|
|
"\u0000\u0000\u0000\u02f0\u02f1\u0005^\u0000\u0000\u02f1\u02f2\u0005\u00cb"+
|
|
"\u0000\u0000\u02f2\u02f3\u0003\u0018\f\u0000\u02f3\u02f4\u0005\u00cc\u0000"+
|
|
"\u0000\u02f4\u02fb\u0001\u0000\u0000\u0000\u02f5\u02f6\u0005_\u0000\u0000"+
|
|
"\u02f6\u02f7\u0005\u00cb\u0000\u0000\u02f7\u02f8\u0003\u0018\f\u0000\u02f8"+
|
|
"\u02f9\u0005\u00cc\u0000\u0000\u02f9\u02fb\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0159\u0001\u0000\u0000\u0000\u02fa\u015e\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0163\u0001\u0000\u0000\u0000\u02fa\u0168\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u016d\u0001\u0000\u0000\u0000\u02fa\u0172\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0177\u0001\u0000\u0000\u0000\u02fa\u017c\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0181\u0001\u0000\u0000\u0000\u02fa\u0186\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u018b\u0001\u0000\u0000\u0000\u02fa\u0190\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0195\u0001\u0000\u0000\u0000\u02fa\u019a\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u019f\u0001\u0000\u0000\u0000\u02fa\u01a4\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01a9\u0001\u0000\u0000\u0000\u02fa\u01ae\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01b3\u0001\u0000\u0000\u0000\u02fa\u01b8\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01bd\u0001\u0000\u0000\u0000\u02fa\u01c2\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01c7\u0001\u0000\u0000\u0000\u02fa\u01cc\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01d1\u0001\u0000\u0000\u0000\u02fa\u01d6\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01db\u0001\u0000\u0000\u0000\u02fa\u01e0\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01e5\u0001\u0000\u0000\u0000\u02fa\u01ea\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01ef\u0001\u0000\u0000\u0000\u02fa\u01f4\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u01f9\u0001\u0000\u0000\u0000\u02fa\u01fe\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0203\u0001\u0000\u0000\u0000\u02fa\u0208\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u020d\u0001\u0000\u0000\u0000\u02fa\u0212\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0217\u0001\u0000\u0000\u0000\u02fa\u021c\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0221\u0001\u0000\u0000\u0000\u02fa\u022a\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u022f\u0001\u0000\u0000\u0000\u02fa\u0234\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0239\u0001\u0000\u0000\u0000\u02fa\u023e\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0243\u0001\u0000\u0000\u0000\u02fa\u0248\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u024d\u0001\u0000\u0000\u0000\u02fa\u0252\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0257\u0001\u0000\u0000\u0000\u02fa\u0260\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0265\u0001\u0000\u0000\u0000\u02fa\u026a\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0273\u0001\u0000\u0000\u0000\u02fa\u027c\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0281\u0001\u0000\u0000\u0000\u02fa\u0286\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u028b\u0001\u0000\u0000\u0000\u02fa\u0290\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u0295\u0001\u0000\u0000\u0000\u02fa\u029a\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u029f\u0001\u0000\u0000\u0000\u02fa\u02a4\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02a9\u0001\u0000\u0000\u0000\u02fa\u02ae\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02b3\u0001\u0000\u0000\u0000\u02fa\u02b8\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02bd\u0001\u0000\u0000\u0000\u02fa\u02c2\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02cb\u0001\u0000\u0000\u0000\u02fa\u02d4\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02dd\u0001\u0000\u0000\u0000\u02fa\u02e6\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02eb\u0001\u0000\u0000\u0000\u02fa\u02f0\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02f5\u0001\u0000\u0000\u0000\u02fb1\u0001\u0000\u0000\u0000\u02fc\u02fd"+
|
|
"\u0005\u001d\u0000\u0000\u02fd\u02fe\u0005\u00cb\u0000\u0000\u02fe\u02ff"+
|
|
"\u0003\u0018\f\u0000\u02ff\u0300\u0005\u00cd\u0000\u0000\u0300\u0301\u0003"+
|
|
"\u0018\f\u0000\u0301\u0302\u0005\u00cc\u0000\u0000\u0302\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u0303\u0304\u0005\u0007\u0000\u0000\u0304\u0305\u0005\u00cb"+
|
|
"\u0000\u0000\u0305\u0306\u0003\u0018\f\u0000\u0306\u0307\u0005\u00cd\u0000"+
|
|
"\u0000\u0307\u0308\u0003\u0018\f\u0000\u0308\u0309\u0005\u00cc\u0000\u0000"+
|
|
"\u0309\u0451\u0001\u0000\u0000\u0000\u030a\u030b\u0005\u0015\u0000\u0000"+
|
|
"\u030b\u030c\u0005\u00cb\u0000\u0000\u030c\u030d\u0003\u0018\f\u0000\u030d"+
|
|
"\u030e\u0005\u00cd\u0000\u0000\u030e\u030f\u0003\u0018\f\u0000\u030f\u0310"+
|
|
"\u0005\u00cc\u0000\u0000\u0310\u0451\u0001\u0000\u0000\u0000\u0311\u0312"+
|
|
"\u0005\u0016\u0000\u0000\u0312\u0313\u0005\u00cb\u0000\u0000\u0313\u0314"+
|
|
"\u0003\u0018\f\u0000\u0314\u0315\u0005\u00cd\u0000\u0000\u0315\u0316\u0003"+
|
|
"\u0018\f\u0000\u0316\u0317\u0005\u00cc\u0000\u0000\u0317\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u0318\u0319\u0005\'\u0000\u0000\u0319\u031a\u0005\u00cb\u0000"+
|
|
"\u0000\u031a\u031b\u0003\u0018\f\u0000\u031b\u031c\u0005\u00cd\u0000\u0000"+
|
|
"\u031c\u031d\u0003\u0018\f\u0000\u031d\u031e\u0005\u00cc\u0000\u0000\u031e"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u031f\u0320\u00057\u0000\u0000\u0320\u0321"+
|
|
"\u0005\u00cb\u0000\u0000\u0321\u0322\u0003\u0018\f\u0000\u0322\u0323\u0005"+
|
|
"\u00cd\u0000\u0000\u0323\u0324\u0003\u0018\f\u0000\u0324\u0325\u0005\u00cc"+
|
|
"\u0000\u0000\u0325\u0451\u0001\u0000\u0000\u0000\u0326\u0327\u00058\u0000"+
|
|
"\u0000\u0327\u0328\u0005\u00cb\u0000\u0000\u0328\u0329\u0003\u0018\f\u0000"+
|
|
"\u0329\u032a\u0005\u00cd\u0000\u0000\u032a\u032b\u0003\u0018\f\u0000\u032b"+
|
|
"\u032c\u0005\u00cc\u0000\u0000\u032c\u0451\u0001\u0000\u0000\u0000\u032d"+
|
|
"\u032e\u0005>\u0000\u0000\u032e\u032f\u0005\u00cb\u0000\u0000\u032f\u0330"+
|
|
"\u0003\u0018\f\u0000\u0330\u0331\u0005\u00cd\u0000\u0000\u0331\u0332\u0003"+
|
|
"\u0018\f\u0000\u0332\u0333\u0005\u00cc\u0000\u0000\u0333\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u0334\u0335\u0005?\u0000\u0000\u0335\u0336\u0005\u00cb\u0000"+
|
|
"\u0000\u0336\u0337\u0003\u0018\f\u0000\u0337\u0338\u0005\u00cd\u0000\u0000"+
|
|
"\u0338\u0339\u0003\u0018\f\u0000\u0339\u033a\u0005\u00cc\u0000\u0000\u033a"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u033b\u033c\u0005@\u0000\u0000\u033c\u033d"+
|
|
"\u0005\u00cb\u0000\u0000\u033d\u033e\u0003\u0018\f\u0000\u033e\u033f\u0005"+
|
|
"\u00cd\u0000\u0000\u033f\u0340\u0003\u0018\f\u0000\u0340\u0341\u0005\u00cc"+
|
|
"\u0000\u0000\u0341\u0451\u0001\u0000\u0000\u0000\u0342\u0343\u0005A\u0000"+
|
|
"\u0000\u0343\u0344\u0005\u00cb\u0000\u0000\u0344\u0345\u0003\u0018\f\u0000"+
|
|
"\u0345\u0346\u0005\u00cd\u0000\u0000\u0346\u0347\u0003\u0018\f\u0000\u0347"+
|
|
"\u0348\u0005\u00cc\u0000\u0000\u0348\u0451\u0001\u0000\u0000\u0000\u0349"+
|
|
"\u034a\u0005U\u0000\u0000\u034a\u034b\u0005\u00cb\u0000\u0000\u034b\u034c"+
|
|
"\u0003\u0018\f\u0000\u034c\u034d\u0005\u00cd\u0000\u0000\u034d\u034e\u0003"+
|
|
"\u0018\f\u0000\u034e\u034f\u0005\u00cc\u0000\u0000\u034f\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u0350\u0351\u0005\u009e\u0000\u0000\u0351\u0352\u0005\u00cb"+
|
|
"\u0000\u0000\u0352\u0353\u0003\u0018\f\u0000\u0353\u0354\u0005\u00cd\u0000"+
|
|
"\u0000\u0354\u0355\u0003\u0018\f\u0000\u0355\u0356\u0005\u00cc\u0000\u0000"+
|
|
"\u0356\u0451\u0001\u0000\u0000\u0000\u0357\u0358\u0005\u00a0\u0000\u0000"+
|
|
"\u0358\u0359\u0005\u00cb\u0000\u0000\u0359\u035a\u0003\u0018\f\u0000\u035a"+
|
|
"\u035b\u0005\u00cd\u0000\u0000\u035b\u035c\u0003\u0018\f\u0000\u035c\u035d"+
|
|
"\u0005\u00cc\u0000\u0000\u035d\u0451\u0001\u0000\u0000\u0000\u035e\u035f"+
|
|
"\u0005\u00a1\u0000\u0000\u035f\u0360\u0005\u00cb\u0000\u0000\u0360\u0361"+
|
|
"\u0003\u0018\f\u0000\u0361\u0362\u0005\u00cd\u0000\u0000\u0362\u0363\u0003"+
|
|
"\u0018\f\u0000\u0363\u0364\u0005\u00cc\u0000\u0000\u0364\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u0365\u0366\u0005X\u0000\u0000\u0366\u0367\u0005\u00cb\u0000"+
|
|
"\u0000\u0367\u0368\u0003\u0018\f\u0000\u0368\u0369\u0005\u00cd\u0000\u0000"+
|
|
"\u0369\u036a\u0003\u0018\f\u0000\u036a\u036b\u0005\u00cc\u0000\u0000\u036b"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u036c\u036d\u00052\u0000\u0000\u036d\u036e"+
|
|
"\u0005\u00cb\u0000\u0000\u036e\u036f\u0003\u0018\f\u0000\u036f\u0370\u0005"+
|
|
"\u00cd\u0000\u0000\u0370\u0371\u0003\u0018\f\u0000\u0371\u0372\u0005\u00cc"+
|
|
"\u0000\u0000\u0372\u0451\u0001\u0000\u0000\u0000\u0373\u0374\u0005H\u0000"+
|
|
"\u0000\u0374\u0375\u0005\u00cb\u0000\u0000\u0375\u0376\u0003\u0018\f\u0000"+
|
|
"\u0376\u0377\u0005\u00cd\u0000\u0000\u0377\u037a\u0003\u0018\f\u0000\u0378"+
|
|
"\u0379\u0005\u00cd\u0000\u0000\u0379\u037b\u0003\u0018\f\u0000\u037a\u0378"+
|
|
"\u0001\u0000\u0000\u0000\u037a\u037b\u0001\u0000\u0000\u0000\u037b\u037c"+
|
|
"\u0001\u0000\u0000\u0000\u037c\u037d\u0005\u00cc\u0000\u0000\u037d\u0451"+
|
|
"\u0001\u0000\u0000\u0000\u037e\u037f\u0005M\u0000\u0000\u037f\u0380\u0005"+
|
|
"\u00cb\u0000\u0000\u0380\u0381\u0003\u0018\f\u0000\u0381\u0382\u0005\u00cd"+
|
|
"\u0000\u0000\u0382\u0383\u0003\u0018\f\u0000\u0383\u0384\u0005\u00cc\u0000"+
|
|
"\u0000\u0384\u0451\u0001\u0000\u0000\u0000\u0385\u0386\u0005N\u0000\u0000"+
|
|
"\u0386\u0387\u0005\u00cb\u0000\u0000\u0387\u0388\u0003\u0018\f\u0000\u0388"+
|
|
"\u0389\u0005\u00cd\u0000\u0000\u0389\u038a\u0003\u0018\f\u0000\u038a\u038b"+
|
|
"\u0005\u00cc\u0000\u0000\u038b\u0451\u0001\u0000\u0000\u0000\u038c\u038d"+
|
|
"\u0005[\u0000\u0000\u038d\u038e\u0005\u00cb\u0000\u0000\u038e\u038f\u0003"+
|
|
"\u0018\f\u0000\u038f\u0390\u0005\u00cd\u0000\u0000\u0390\u0391\u0003\u0018"+
|
|
"\f\u0000\u0391\u0392\u0005\u00cc\u0000\u0000\u0392\u0451\u0001\u0000\u0000"+
|
|
"\u0000\u0393\u0394\u0005n\u0000\u0000\u0394\u0395\u0005\u00cb\u0000\u0000"+
|
|
"\u0395\u0396\u0003\u0018\f\u0000\u0396\u0397\u0005\u00cd\u0000\u0000\u0397"+
|
|
"\u0398\u0003\u0018\f\u0000\u0398\u0399\u0005\u00cc\u0000\u0000\u0399\u0451"+
|
|
"\u0001\u0000\u0000\u0000\u039a\u039b\u0005Y\u0000\u0000\u039b\u039c\u0005"+
|
|
"\u00cb\u0000\u0000\u039c\u039d\u0003\u0018\f\u0000\u039d\u039e\u0005\u00cd"+
|
|
"\u0000\u0000\u039e\u039f\u0003\u0018\f\u0000\u039f\u03a0\u0005\u00cc\u0000"+
|
|
"\u0000\u03a0\u0451\u0001\u0000\u0000\u0000\u03a1\u03a2\u0005m\u0000\u0000"+
|
|
"\u03a2\u03a3\u0005\u00cb\u0000\u0000\u03a3\u03aa\u0003(\u0014\u0000\u03a4"+
|
|
"\u03a5\u0005\u00cd\u0000\u0000\u03a5\u03a8\u0003\u0018\f\u0000\u03a6\u03a7"+
|
|
"\u0005\u00cd\u0000\u0000\u03a7\u03a9\u0003\u0018\f\u0000\u03a8\u03a6\u0001"+
|
|
"\u0000\u0000\u0000\u03a8\u03a9\u0001\u0000\u0000\u0000\u03a9\u03ab\u0001"+
|
|
"\u0000\u0000\u0000\u03aa\u03a4\u0001\u0000\u0000\u0000\u03aa\u03ab\u0001"+
|
|
"\u0000\u0000\u0000\u03ab\u03ac\u0001\u0000\u0000\u0000\u03ac\u03ad\u0005"+
|
|
"\u00cc\u0000\u0000\u03ad\u0451\u0001\u0000\u0000\u0000\u03ae\u03af\u0005"+
|
|
"c\u0000\u0000\u03af\u03b0\u0005\u00cb\u0000\u0000\u03b0\u03b1\u0003\u0018"+
|
|
"\f\u0000\u03b1\u03b2\u0005\u00cd\u0000\u0000\u03b2\u03b3\u0003\u0018\f"+
|
|
"\u0000\u03b3\u03b4\u0005\u00cc\u0000\u0000\u03b4\u0451\u0001\u0000\u0000"+
|
|
"\u0000\u03b5\u03b6\u0005d\u0000\u0000\u03b6\u03b7\u0005\u00cb\u0000\u0000"+
|
|
"\u03b7\u03b8\u0003\u0018\f\u0000\u03b8\u03b9\u0005\u00cd\u0000\u0000\u03b9"+
|
|
"\u03ba\u0003\u0018\f\u0000\u03ba\u03bb\u0005\u00cc\u0000\u0000\u03bb\u0451"+
|
|
"\u0001\u0000\u0000\u0000\u03bc\u03bd\u0005e\u0000\u0000\u03bd\u03be\u0005"+
|
|
"\u00cb\u0000\u0000\u03be\u03bf\u0003\u0018\f\u0000\u03bf\u03c0\u0005\u00cd"+
|
|
"\u0000\u0000\u03c0\u03c1\u0003\u0018\f\u0000\u03c1\u03c2\u0005\u00cc\u0000"+
|
|
"\u0000\u03c2\u0451\u0001\u0000\u0000\u0000\u03c3\u03c4\u0005Z\u0000\u0000"+
|
|
"\u03c4\u03c5\u0005\u00cb\u0000\u0000\u03c5\u03c6\u0003\u0018\f\u0000\u03c6"+
|
|
"\u03c7\u0005\u00cd\u0000\u0000\u03c7\u03c8\u0003\u0018\f\u0000\u03c8\u03c9"+
|
|
"\u0005\u00cc\u0000\u0000\u03c9\u0451\u0001\u0000\u0000\u0000\u03ca\u03cb"+
|
|
"\u0005f\u0000\u0000\u03cb\u03cc\u0005\u00cb\u0000\u0000\u03cc\u03cd\u0003"+
|
|
"\u0018\f\u0000\u03cd\u03ce\u0005\u00cd\u0000\u0000\u03ce\u03d9\u0003\u0018"+
|
|
"\f\u0000\u03cf\u03d0\u0005\u00cd\u0000\u0000\u03d0\u03d7\u0003\u0018\f"+
|
|
"\u0000\u03d1\u03d2\u0005\u00cd\u0000\u0000\u03d2\u03d5\u0003\u0018\f\u0000"+
|
|
"\u03d3\u03d4\u0005\u00cd\u0000\u0000\u03d4\u03d6\u0003\u0018\f\u0000\u03d5"+
|
|
"\u03d3\u0001\u0000\u0000\u0000\u03d5\u03d6\u0001\u0000\u0000\u0000\u03d6"+
|
|
"\u03d8\u0001\u0000\u0000\u0000\u03d7\u03d1\u0001\u0000\u0000\u0000\u03d7"+
|
|
"\u03d8\u0001\u0000\u0000\u0000\u03d8\u03da\u0001\u0000\u0000\u0000\u03d9"+
|
|
"\u03cf\u0001\u0000\u0000\u0000\u03d9\u03da\u0001\u0000\u0000\u0000\u03da"+
|
|
"\u03db\u0001\u0000\u0000\u0000\u03db\u03dc\u0005\u00cc\u0000\u0000\u03dc"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u03dd\u03de\u0005j\u0000\u0000\u03de\u03df"+
|
|
"\u0005\u00cb\u0000\u0000\u03df\u03e0\u0003\u0018\f\u0000\u03e0\u03e1\u0005"+
|
|
"\u00cd\u0000\u0000\u03e1\u03e2\u0003\u0018\f\u0000\u03e2\u03e3\u0005\u00cc"+
|
|
"\u0000\u0000\u03e3\u0451\u0001\u0000\u0000\u0000\u03e4\u03e5\u0005k\u0000"+
|
|
"\u0000\u03e5\u03e6\u0005\u00cb\u0000\u0000\u03e6\u03e7\u0003\u0018\f\u0000"+
|
|
"\u03e7\u03e8\u0005\u00cd\u0000\u0000\u03e8\u03e9\u0003\u0018\f\u0000\u03e9"+
|
|
"\u03ea\u0005\u00cc\u0000\u0000\u03ea\u0451\u0001\u0000\u0000\u0000\u03eb"+
|
|
"\u03ec\u0005l\u0000\u0000\u03ec\u03ed\u0005\u00cb\u0000\u0000\u03ed\u03ee"+
|
|
"\u0003\u0018\f\u0000\u03ee\u03ef\u0005\u00cd\u0000\u0000\u03ef\u03f0\u0003"+
|
|
"\u0018\f\u0000\u03f0\u03f1\u0005\u00cc\u0000\u0000\u03f1\u0451\u0001\u0000"+
|
|
"\u0000\u0000\u03f2\u03f3\u0005y\u0000\u0000\u03f3\u03f4\u0005\u00cb\u0000"+
|
|
"\u0000\u03f4\u03f7\u0003\u0018\f\u0000\u03f5\u03f6\u0005\u00cd\u0000\u0000"+
|
|
"\u03f6\u03f8\u0003\u0018\f\u0000\u03f7\u03f5\u0001\u0000\u0000\u0000\u03f7"+
|
|
"\u03f8\u0001\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000\u03f9"+
|
|
"\u03fa\u0005\u00cc\u0000\u0000\u03fa\u0451\u0001\u0000\u0000\u0000\u03fb"+
|
|
"\u03fc\u0005z\u0000\u0000\u03fc\u03fd\u0005\u00cb\u0000\u0000\u03fd\u0400"+
|
|
"\u0003\u0018\f\u0000\u03fe\u03ff\u0005\u00cd\u0000\u0000\u03ff\u0401\u0003"+
|
|
"\u0018\f\u0000\u0400\u03fe\u0001\u0000\u0000\u0000\u0400\u0401\u0001\u0000"+
|
|
"\u0000\u0000\u0401\u0402\u0001\u0000\u0000\u0000\u0402\u0403\u0005\u00cc"+
|
|
"\u0000\u0000\u0403\u0451\u0001\u0000\u0000\u0000\u0404\u0405\u0005{\u0000"+
|
|
"\u0000\u0405\u0406\u0005\u00cb\u0000\u0000\u0406\u0407\u0003\u0018\f\u0000"+
|
|
"\u0407\u0408\u0005\u00cd\u0000\u0000\u0408\u040b\u0003\u0018\f\u0000\u0409"+
|
|
"\u040a\u0005\u00cd\u0000\u0000\u040a\u040c\u0003\u0018\f\u0000\u040b\u0409"+
|
|
"\u0001\u0000\u0000\u0000\u040b\u040c\u0001\u0000\u0000\u0000\u040c\u040d"+
|
|
"\u0001\u0000\u0000\u0000\u040d\u040e\u0005\u00cc\u0000\u0000\u040e\u0451"+
|
|
"\u0001\u0000\u0000\u0000\u040f\u0410\u0005|\u0000\u0000\u0410\u0411\u0005"+
|
|
"\u00cb\u0000\u0000\u0411\u0412\u0003\u0018\f\u0000\u0412\u0413\u0005\u00cd"+
|
|
"\u0000\u0000\u0413\u0416\u0003\u0018\f\u0000\u0414\u0415\u0005\u00cd\u0000"+
|
|
"\u0000\u0415\u0417\u0003\u0018\f\u0000\u0416\u0414\u0001\u0000\u0000\u0000"+
|
|
"\u0416\u0417\u0001\u0000\u0000\u0000\u0417\u0418\u0001\u0000\u0000\u0000"+
|
|
"\u0418\u0419\u0005\u00cc\u0000\u0000\u0419\u0451\u0001\u0000\u0000\u0000"+
|
|
"\u041a\u041b\u0005}\u0000\u0000\u041b\u041c\u0005\u00cb\u0000\u0000\u041c"+
|
|
"\u041d\u0003\u0018\f\u0000\u041d\u041e\u0005\u00cd\u0000\u0000\u041e\u041f"+
|
|
"\u0003\u0018\f\u0000\u041f\u0420\u0005\u00cc\u0000\u0000\u0420\u0451\u0001"+
|
|
"\u0000\u0000\u0000\u0421\u0422\u0005~\u0000\u0000\u0422\u0423\u0005\u00cb"+
|
|
"\u0000\u0000\u0423\u0424\u0003\u0018\f\u0000\u0424\u0425\u0005\u00cd\u0000"+
|
|
"\u0000\u0425\u0426\u0003\u0018\f\u0000\u0426\u0427\u0005\u00cd\u0000\u0000"+
|
|
"\u0427\u0428\u0003\u0018\f\u0000\u0428\u0429\u0005\u00cc\u0000\u0000\u0429"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u042a\u042b\u0005\u0089\u0000\u0000\u042b"+
|
|
"\u042c\u0005\u00cb\u0000\u0000\u042c\u042d\u0003\u0018\f\u0000\u042d\u042e"+
|
|
"\u0005\u00cc\u0000\u0000\u042e\u0451\u0001\u0000\u0000\u0000\u042f\u0430"+
|
|
"\u0005\u008a\u0000\u0000\u0430\u0431\u0005\u00cb\u0000\u0000\u0431\u0437"+
|
|
"\u0003\u0018\f\u0000\u0432\u0433\u0005\u00cd\u0000\u0000\u0433\u0434\u0003"+
|
|
"\u0018\f\u0000\u0434\u0435\u0005\u00cd\u0000\u0000\u0435\u0436\u0003\u0018"+
|
|
"\f\u0000\u0436\u0438\u0001\u0000\u0000\u0000\u0437\u0432\u0001\u0000\u0000"+
|
|
"\u0000\u0437\u0438\u0001\u0000\u0000\u0000\u0438\u0439\u0001\u0000\u0000"+
|
|
"\u0000\u0439\u043a\u0005\u00cc\u0000\u0000\u043a\u0451\u0001\u0000\u0000"+
|
|
"\u0000\u043b\u043c\u0005\u008b\u0000\u0000\u043c\u043d\u0005\u00cb\u0000"+
|
|
"\u0000\u043d\u043e\u0003\u0018\f\u0000\u043e\u043f\u0005\u00cd\u0000\u0000"+
|
|
"\u043f\u0440\u0003\u0018\f\u0000\u0440\u0441\u0005\u00cc\u0000\u0000\u0441"+
|
|
"\u0451\u0001\u0000\u0000\u0000\u0442\u0443\u0005\u008c\u0000\u0000\u0443"+
|
|
"\u0444\u0005\u00cb\u0000\u0000\u0444\u0445\u0003\u0018\f\u0000\u0445\u0446"+
|
|
"\u0005\u00cd\u0000\u0000\u0446\u0447\u0003\u0018\f\u0000\u0447\u0448\u0005"+
|
|
"\u00cc\u0000\u0000\u0448\u0451\u0001\u0000\u0000\u0000\u0449\u044a\u0005"+
|
|
"\u008d\u0000\u0000\u044a\u044b\u0005\u00cb\u0000\u0000\u044b\u044c\u0003"+
|
|
"\u0018\f\u0000\u044c\u044d\u0005\u00cd\u0000\u0000\u044d\u044e\u0003\u0018"+
|
|
"\f\u0000\u044e\u044f\u0005\u00cc\u0000\u0000\u044f\u0451\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u02fc\u0001\u0000\u0000\u0000\u0450\u0303\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u030a\u0001\u0000\u0000\u0000\u0450\u0311\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0318\u0001\u0000\u0000\u0000\u0450\u031f\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0326\u0001\u0000\u0000\u0000\u0450\u032d\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0334\u0001\u0000\u0000\u0000\u0450\u033b\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0342\u0001\u0000\u0000\u0000\u0450\u0349\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0350\u0001\u0000\u0000\u0000\u0450\u0357\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u035e\u0001\u0000\u0000\u0000\u0450\u0365\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u036c\u0001\u0000\u0000\u0000\u0450\u0373\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u037e\u0001\u0000\u0000\u0000\u0450\u0385\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u038c\u0001\u0000\u0000\u0000\u0450\u0393\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u039a\u0001\u0000\u0000\u0000\u0450\u03a1\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u03ae\u0001\u0000\u0000\u0000\u0450\u03b5\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u03bc\u0001\u0000\u0000\u0000\u0450\u03c3\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u03ca\u0001\u0000\u0000\u0000\u0450\u03dd\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u03e4\u0001\u0000\u0000\u0000\u0450\u03eb\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u03f2\u0001\u0000\u0000\u0000\u0450\u03fb\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0404\u0001\u0000\u0000\u0000\u0450\u040f\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u041a\u0001\u0000\u0000\u0000\u0450\u0421\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u042a\u0001\u0000\u0000\u0000\u0450\u042f\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u043b\u0001\u0000\u0000\u0000\u0450\u0442\u0001\u0000\u0000"+
|
|
"\u0000\u0450\u0449\u0001\u0000\u0000\u0000\u04513\u0001\u0000\u0000\u0000"+
|
|
"\u0452\u0453\u0005\u001f\u0000\u0000\u0453\u0454\u0005\u00cb\u0000\u0000"+
|
|
"\u0454\u0455\u0003\u0018\f\u0000\u0455\u0456\u0005\u00cd\u0000\u0000\u0456"+
|
|
"\u0457\u0003\u0018\f\u0000\u0457\u0458\u0005\u00cd\u0000\u0000\u0458\u0459"+
|
|
"\u0003\u0018\f\u0000\u0459\u045a\u0005\u00cc\u0000\u0000\u045a\u0530\u0001"+
|
|
"\u0000\u0000\u0000\u045b\u045c\u0005&\u0000\u0000\u045c\u045d\u0005\u00cb"+
|
|
"\u0000\u0000\u045d\u045e\u0003\u0018\f\u0000\u045e\u045f\u0005\u00cd\u0000"+
|
|
"\u0000\u045f\u0460\u0003\u0018\f\u0000\u0460\u0461\u0005\u00cd\u0000\u0000"+
|
|
"\u0461\u0462\u0003\u0018\f\u0000\u0462\u0463\u0005\u00cc\u0000\u0000\u0463"+
|
|
"\u0530\u0001\u0000\u0000\u0000\u0464\u0465\u0005(\u0000\u0000\u0465\u0466"+
|
|
"\u0005\u00cb\u0000\u0000\u0466\u0467\u0003\u0018\f\u0000\u0467\u0468\u0005"+
|
|
"\u00cd\u0000\u0000\u0468\u0469\u0003\u0018\f\u0000\u0469\u046a\u0005\u00cd"+
|
|
"\u0000\u0000\u046a\u046b\u0003\u0018\f\u0000\u046b\u046c\u0005\u00cc\u0000"+
|
|
"\u0000\u046c\u0530\u0001\u0000\u0000\u0000\u046d\u046e\u00054\u0000\u0000"+
|
|
"\u046e\u046f\u0005\u00cb\u0000\u0000\u046f\u0470\u0003\u0018\f\u0000\u0470"+
|
|
"\u0471\u0005\u00cd\u0000\u0000\u0471\u0472\u0003\u0018\f\u0000\u0472\u0473"+
|
|
"\u0005\u00cd\u0000\u0000\u0473\u0474\u0003\u0018\f\u0000\u0474\u0475\u0005"+
|
|
"\u00cc\u0000\u0000\u0475\u0530\u0001\u0000\u0000\u0000\u0476\u0477\u0005"+
|
|
"B\u0000\u0000\u0477\u0478\u0005\u00cb\u0000\u0000\u0478\u0479\u0003\u0018"+
|
|
"\f\u0000\u0479\u047a\u0005\u00cd\u0000\u0000\u047a\u047b\u0003\u0018\f"+
|
|
"\u0000\u047b\u047c\u0005\u00cd\u0000\u0000\u047c\u047d\u0003\u0018\f\u0000"+
|
|
"\u047d\u047e\u0005\u00cc\u0000\u0000\u047e\u0530\u0001\u0000\u0000\u0000"+
|
|
"\u047f\u0480\u0005O\u0000\u0000\u0480\u0481\u0005\u00cb\u0000\u0000\u0481"+
|
|
"\u0482\u0003\u0018\f\u0000\u0482\u0483\u0005\u00cd\u0000\u0000\u0483\u0484"+
|
|
"\u0003\u0018\f\u0000\u0484\u0485\u0005\u00cd\u0000\u0000\u0485\u0486\u0003"+
|
|
"\u0018\f\u0000\u0486\u0487\u0005\u00cc\u0000\u0000\u0487\u0530\u0001\u0000"+
|
|
"\u0000\u0000\u0488\u0489\u0005P\u0000\u0000\u0489\u048a\u0005\u00cb\u0000"+
|
|
"\u0000\u048a\u048b\u0003\u0018\f\u0000\u048b\u048c\u0005\u00cd\u0000\u0000"+
|
|
"\u048c\u048d\u0003\u0018\f\u0000\u048d\u048e\u0005\u00cd\u0000\u0000\u048e"+
|
|
"\u048f\u0003\u0018\f\u0000\u048f\u0490\u0005\u00cc\u0000\u0000\u0490\u0530"+
|
|
"\u0001\u0000\u0000\u0000\u0491\u0492\u0005Q\u0000\u0000\u0492\u0493\u0005"+
|
|
"\u00cb\u0000\u0000\u0493\u0494\u0003\u0018\f\u0000\u0494\u0495\u0005\u00cd"+
|
|
"\u0000\u0000\u0495\u0496\u0003\u0018\f\u0000\u0496\u0497\u0005\u00cd\u0000"+
|
|
"\u0000\u0497\u0498\u0003\u0018\f\u0000\u0498\u0499\u0005\u00cc\u0000\u0000"+
|
|
"\u0499\u0530\u0001\u0000\u0000\u0000\u049a\u049b\u0005R\u0000\u0000\u049b"+
|
|
"\u049c\u0005\u00cb\u0000\u0000\u049c\u049d\u0003\u0018\f\u0000\u049d\u049e"+
|
|
"\u0005\u00cd\u0000\u0000\u049e\u049f\u0003\u0018\f\u0000\u049f\u04a0\u0005"+
|
|
"\u00cd\u0000\u0000\u04a0\u04a1\u0003\u0018\f\u0000\u04a1\u04a2\u0005\u00cc"+
|
|
"\u0000\u0000\u04a2\u0530\u0001\u0000\u0000\u0000\u04a3\u04a4\u0005\u00a3"+
|
|
"\u0000\u0000\u04a4\u04a5\u0005\u00cb\u0000\u0000\u04a5\u04a6\u0003\u0018"+
|
|
"\f\u0000\u04a6\u04a7\u0005\u00cd\u0000\u0000\u04a7\u04a8\u0003\u0018\f"+
|
|
"\u0000\u04a8\u04a9\u0005\u00cd\u0000\u0000\u04a9\u04aa\u0003\u0018\f\u0000"+
|
|
"\u04aa\u04ab\u0005\u00cc\u0000\u0000\u04ab\u0530\u0001\u0000\u0000\u0000"+
|
|
"\u04ac\u04ad\u0005!\u0000\u0000\u04ad\u04ae\u0005\u00cb\u0000\u0000\u04ae"+
|
|
"\u04b1\u0003\u0018\f\u0000\u04af\u04b0\u0005\u00cd\u0000\u0000\u04b0\u04b2"+
|
|
"\u0003\u0018\f\u0000\u04b1\u04af\u0001\u0000\u0000\u0000\u04b1\u04b2\u0001"+
|
|
"\u0000\u0000\u0000\u04b2\u04b3\u0001\u0000\u0000\u0000\u04b3\u04b4\u0005"+
|
|
"\u00cc\u0000\u0000\u04b4\u0530\u0001\u0000\u0000\u0000\u04b5\u04b6\u0005"+
|
|
"b\u0000\u0000\u04b6\u04b7\u0005\u00cb\u0000\u0000\u04b7\u04b8\u0003\u0018"+
|
|
"\f\u0000\u04b8\u04b9\u0005\u00cd\u0000\u0000\u04b9\u04ba\u0003\u0018\f"+
|
|
"\u0000\u04ba\u04bb\u0005\u00cd\u0000\u0000\u04bb\u04be\u0003\u0018\f\u0000"+
|
|
"\u04bc\u04bd\u0005\u00cd\u0000\u0000\u04bd\u04bf\u0003\u0018\f\u0000\u04be"+
|
|
"\u04bc\u0001\u0000\u0000\u0000\u04be\u04bf\u0001\u0000\u0000\u0000\u04bf"+
|
|
"\u04c0\u0001\u0000\u0000\u0000\u04c0\u04c1\u0005\u00cc\u0000\u0000\u04c1"+
|
|
"\u0530\u0001\u0000\u0000\u0000\u04c2\u04c3\u00055\u0000\u0000\u04c3\u04c4"+
|
|
"\u0005\u00cb\u0000\u0000\u04c4\u04c5\u0003\u0018\f\u0000\u04c5\u04c6\u0005"+
|
|
"\u00cd\u0000\u0000\u04c6\u04c7\u0003\u0018\f\u0000\u04c7\u04c8\u0005\u00cd"+
|
|
"\u0000\u0000\u04c8\u04c9\u0003\u0018\f\u0000\u04c9\u04ca\u0005\u00cc\u0000"+
|
|
"\u0000\u04ca\u0530\u0001\u0000\u0000\u0000\u04cb\u04cc\u0005\u009f\u0000"+
|
|
"\u0000\u04cc\u04cd\u0005\u00cb\u0000\u0000\u04cd\u04ce\u0003\u0018\f\u0000"+
|
|
"\u04ce\u04cf\u0005\u00cd\u0000\u0000\u04cf\u04d2\u0003\u0018\f\u0000\u04d0"+
|
|
"\u04d1\u0005\u00cd\u0000\u0000\u04d1\u04d3\u0003\u0018\f\u0000\u04d2\u04d0"+
|
|
"\u0001\u0000\u0000\u0000\u04d2\u04d3\u0001\u0000\u0000\u0000\u04d3\u04d4"+
|
|
"\u0001\u0000\u0000\u0000\u04d4\u04d5\u0005\u00cc\u0000\u0000\u04d5\u0530"+
|
|
"\u0001\u0000\u0000\u0000\u04d6\u04d7\u0005\u0083\u0000\u0000\u04d7\u04d8"+
|
|
"\u0005\u00cb\u0000\u0000\u04d8\u04de\u0003\u0018\f\u0000\u04d9\u04da\u0005"+
|
|
"\u00cd\u0000\u0000\u04da\u04db\u0003\u0018\f\u0000\u04db\u04dc\u0005\u00cd"+
|
|
"\u0000\u0000\u04dc\u04dd\u0003\u0018\f\u0000\u04dd\u04df\u0001\u0000\u0000"+
|
|
"\u0000\u04de\u04d9\u0001\u0000\u0000\u0000\u04de\u04df\u0001\u0000\u0000"+
|
|
"\u0000\u04df\u04e0\u0001\u0000\u0000\u0000\u04e0\u04e1\u0005\u00cc\u0000"+
|
|
"\u0000\u04e1\u0530\u0001\u0000\u0000\u0000\u04e2\u04e3\u0005\u0084\u0000"+
|
|
"\u0000\u04e3\u04e4\u0005\u00cb\u0000\u0000\u04e4\u04ea\u0003\u0018\f\u0000"+
|
|
"\u04e5\u04e6\u0005\u00cd\u0000\u0000\u04e6\u04e7\u0003\u0018\f\u0000\u04e7"+
|
|
"\u04e8\u0005\u00cd\u0000\u0000\u04e8\u04e9\u0003\u0018\f\u0000\u04e9\u04eb"+
|
|
"\u0001\u0000\u0000\u0000\u04ea\u04e5\u0001\u0000\u0000\u0000\u04ea\u04eb"+
|
|
"\u0001\u0000\u0000\u0000\u04eb\u04ec\u0001\u0000\u0000\u0000\u04ec\u04ed"+
|
|
"\u0005\u00cc\u0000\u0000\u04ed\u0530\u0001\u0000\u0000\u0000\u04ee\u04ef"+
|
|
"\u0005\u0087\u0000\u0000\u04ef\u04f0\u0005\u00cb\u0000\u0000\u04f0\u04f6"+
|
|
"\u0003\u0018\f\u0000\u04f1\u04f2\u0005\u00cd\u0000\u0000\u04f2\u04f3\u0003"+
|
|
"\u0018\f\u0000\u04f3\u04f4\u0005\u00cd\u0000\u0000\u04f4\u04f5\u0003\u0018"+
|
|
"\f\u0000\u04f5\u04f7\u0001\u0000\u0000\u0000\u04f6\u04f1\u0001\u0000\u0000"+
|
|
"\u0000\u04f6\u04f7\u0001\u0000\u0000\u0000\u04f7\u04fa\u0001\u0000\u0000"+
|
|
"\u0000\u04f8\u04f9\u0005\u00cd\u0000\u0000\u04f9\u04fb\u0003\u0018\f\u0000"+
|
|
"\u04fa\u04f8\u0001\u0000\u0000\u0000\u04fa\u04fb\u0001\u0000\u0000\u0000"+
|
|
"\u04fb\u04fc\u0001\u0000\u0000\u0000\u04fc\u04fd\u0005\u00cc\u0000\u0000"+
|
|
"\u04fd\u0530\u0001\u0000\u0000\u0000\u04fe\u04ff\u0005\u0088\u0000\u0000"+
|
|
"\u04ff\u0500\u0005\u00cb\u0000\u0000\u0500\u0506\u0003\u0018\f\u0000\u0501"+
|
|
"\u0502\u0005\u00cd\u0000\u0000\u0502\u0503\u0003\u0018\f\u0000\u0503\u0504"+
|
|
"\u0005\u00cd\u0000\u0000\u0504\u0505\u0003\u0018\f\u0000\u0505\u0507\u0001"+
|
|
"\u0000\u0000\u0000\u0506\u0501\u0001\u0000\u0000\u0000\u0506\u0507\u0001"+
|
|
"\u0000\u0000\u0000\u0507\u050a\u0001\u0000\u0000\u0000\u0508\u0509\u0005"+
|
|
"\u00cd\u0000\u0000\u0509\u050b\u0003\u0018\f\u0000\u050a\u0508\u0001\u0000"+
|
|
"\u0000\u0000\u050a\u050b\u0001\u0000\u0000\u0000\u050b\u050c\u0001\u0000"+
|
|
"\u0000\u0000\u050c\u050d\u0005\u00cc\u0000\u0000\u050d\u0530\u0001\u0000"+
|
|
"\u0000\u0000\u050e\u050f\u0005`\u0000\u0000\u050f\u0510\u0005\u00cb\u0000"+
|
|
"\u0000\u0510\u0511\u0003\u0018\f\u0000\u0511\u0512\u0005\u00cd\u0000\u0000"+
|
|
"\u0512\u0513\u0003\u0018\f\u0000\u0513\u0514\u0005\u00cd\u0000\u0000\u0514"+
|
|
"\u0515\u0003\u0018\f\u0000\u0515\u0516\u0005\u00cc\u0000\u0000\u0516\u0530"+
|
|
"\u0001\u0000\u0000\u0000\u0517\u0518\u0005\u0085\u0000\u0000\u0518\u0519"+
|
|
"\u0005\u00cb\u0000\u0000\u0519\u051f\u0003\u0018\f\u0000\u051a\u051b\u0005"+
|
|
"\u00cd\u0000\u0000\u051b\u051c\u0003\u0018\f\u0000\u051c\u051d\u0005\u00cd"+
|
|
"\u0000\u0000\u051d\u051e\u0003\u0018\f\u0000\u051e\u0520\u0001\u0000\u0000"+
|
|
"\u0000\u051f\u051a\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000\u0000"+
|
|
"\u0000\u0520\u0521\u0001\u0000\u0000\u0000\u0521\u0522\u0005\u00cc\u0000"+
|
|
"\u0000\u0522\u0530\u0001\u0000\u0000\u0000\u0523\u0524\u0005\u0086\u0000"+
|
|
"\u0000\u0524\u0525\u0005\u00cb\u0000\u0000\u0525\u052b\u0003\u0018\f\u0000"+
|
|
"\u0526\u0527\u0005\u00cd\u0000\u0000\u0527\u0528\u0003\u0018\f\u0000\u0528"+
|
|
"\u0529\u0005\u00cd\u0000\u0000\u0529\u052a\u0003\u0018\f\u0000\u052a\u052c"+
|
|
"\u0001\u0000\u0000\u0000\u052b\u0526\u0001\u0000\u0000\u0000\u052b\u052c"+
|
|
"\u0001\u0000\u0000\u0000\u052c\u052d\u0001\u0000\u0000\u0000\u052d\u052e"+
|
|
"\u0005\u00cc\u0000\u0000\u052e\u0530\u0001\u0000\u0000\u0000\u052f\u0452"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u045b\u0001\u0000\u0000\u0000\u052f\u0464"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u046d\u0001\u0000\u0000\u0000\u052f\u0476"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u047f\u0001\u0000\u0000\u0000\u052f\u0488"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u0491\u0001\u0000\u0000\u0000\u052f\u049a"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u04a3\u0001\u0000\u0000\u0000\u052f\u04ac"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u04b5\u0001\u0000\u0000\u0000\u052f\u04c2"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u04cb\u0001\u0000\u0000\u0000\u052f\u04d6"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u04e2\u0001\u0000\u0000\u0000\u052f\u04ee"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u04fe\u0001\u0000\u0000\u0000\u052f\u050e"+
|
|
"\u0001\u0000\u0000\u0000\u052f\u0517\u0001\u0000\u0000\u0000\u052f\u0523"+
|
|
"\u0001\u0000\u0000\u0000\u05305\u0001\u0000\u0000\u0000\u0531\u0532\u0005"+
|
|
"1\u0000\u0000\u0532\u0533\u0005\u00cb\u0000\u0000\u0533\u0534\u0003\u0018"+
|
|
"\f\u0000\u0534\u0535\u0005\u00cd\u0000\u0000\u0535\u0536\u0003\u0018\f"+
|
|
"\u0000\u0536\u0537\u0005\u00cd\u0000\u0000\u0537\u0538\u0003\u0018\f\u0000"+
|
|
"\u0538\u0539\u0005\u00cd\u0000\u0000\u0539\u053a\u0003\u0018\f\u0000\u053a"+
|
|
"\u053b\u0005\u00cc\u0000\u0000\u053b\u0569\u0001\u0000\u0000\u0000\u053c"+
|
|
"\u053d\u0005%\u0000\u0000\u053d\u053e\u0005\u00cb\u0000\u0000\u053e\u053f"+
|
|
"\u0003\u0018\f\u0000\u053f\u0540\u0005\u00cd\u0000\u0000\u0540\u0541\u0003"+
|
|
"\u0018\f\u0000\u0541\u0542\u0005\u00cd\u0000\u0000\u0542\u0543\u0003\u0018"+
|
|
"\f\u0000\u0543\u0544\u0005\u00cd\u0000\u0000\u0544\u0545\u0003\u0018\f"+
|
|
"\u0000\u0545\u0546\u0005\u00cc\u0000\u0000\u0546\u0569\u0001\u0000\u0000"+
|
|
"\u0000\u0547\u0548\u00056\u0000\u0000\u0548\u0549\u0005\u00cb\u0000\u0000"+
|
|
"\u0549\u054a\u0003\u0018\f\u0000\u054a\u054b\u0005\u00cd\u0000\u0000\u054b"+
|
|
"\u054c\u0003\u0018\f\u0000\u054c\u054d\u0005\u00cd\u0000\u0000\u054d\u054e"+
|
|
"\u0003\u0018\f\u0000\u054e\u054f\u0005\u00cd\u0000\u0000\u054f\u0550\u0003"+
|
|
"\u0018\f\u0000\u0550\u0551\u0005\u00cc\u0000\u0000\u0551\u0569\u0001\u0000"+
|
|
"\u0000\u0000\u0552\u0553\u0005S\u0000\u0000\u0553\u0554\u0005\u00cb\u0000"+
|
|
"\u0000\u0554\u0555\u0003\u0018\f\u0000\u0555\u0556\u0005\u00cd\u0000\u0000"+
|
|
"\u0556\u0557\u0003\u0018\f\u0000\u0557\u0558\u0005\u00cd\u0000\u0000\u0558"+
|
|
"\u0559\u0003\u0018\f\u0000\u0559\u055a\u0005\u00cd\u0000\u0000\u055a\u055b"+
|
|
"\u0003\u0018\f\u0000\u055b\u055c\u0005\u00cc\u0000\u0000\u055c\u0569\u0001"+
|
|
"\u0000\u0000\u0000\u055d\u055e\u0005a\u0000\u0000\u055e\u055f\u0005\u00cb"+
|
|
"\u0000\u0000\u055f\u0560\u0003\u0018\f\u0000\u0560\u0561\u0005\u00cd\u0000"+
|
|
"\u0000\u0561\u0562\u0003\u0018\f\u0000\u0562\u0563\u0005\u00cd\u0000\u0000"+
|
|
"\u0563\u0564\u0003\u0018\f\u0000\u0564\u0565\u0005\u00cd\u0000\u0000\u0565"+
|
|
"\u0566\u0003\u0018\f\u0000\u0566\u0567\u0005\u00cc\u0000\u0000\u0567\u0569"+
|
|
"\u0001\u0000\u0000\u0000\u0568\u0531\u0001\u0000\u0000\u0000\u0568\u053c"+
|
|
"\u0001\u0000\u0000\u0000\u0568\u0547\u0001\u0000\u0000\u0000\u0568\u0552"+
|
|
"\u0001\u0000\u0000\u0000\u0568\u055d\u0001\u0000\u0000\u0000\u05697\u0001"+
|
|
"\u0000\u0000\u0000\u056a\u056b\u0005T\u0000\u0000\u056b\u056c\u0005\u00cb"+
|
|
"\u0000\u0000\u056c\u056d\u0003\u0018\f\u0000\u056d\u056e\u0005\u00cd\u0000"+
|
|
"\u0000\u056e\u056f\u0003\u0018\f\u0000\u056f\u0570\u0005\u00cd\u0000\u0000"+
|
|
"\u0570\u0571\u0003\u0018\f\u0000\u0571\u0572\u0005\u00cd\u0000\u0000\u0572"+
|
|
"\u0573\u0003\u0018\f\u0000\u0573\u0574\u0005\u00cd\u0000\u0000\u0574\u0575"+
|
|
"\u0003\u0018\f\u0000\u0575\u0576\u0005\u00cc\u0000\u0000\u05769\u0001"+
|
|
"\u0000\u0000\u0000\u0577\u0578\u0005\u0013\u0000\u0000\u0578\u0579\u0005"+
|
|
"\u00cb\u0000\u0000\u0579\u057e\u0003\u0018\f\u0000\u057a\u057b\u0005\u00cd"+
|
|
"\u0000\u0000\u057b\u057d\u0003\u0018\f\u0000\u057c\u057a\u0001\u0000\u0000"+
|
|
"\u0000\u057d\u0580\u0001\u0000\u0000\u0000\u057e\u057c\u0001\u0000\u0000"+
|
|
"\u0000\u057e\u057f\u0001\u0000\u0000\u0000\u057f\u0581\u0001\u0000\u0000"+
|
|
"\u0000\u0580\u057e\u0001\u0000\u0000\u0000\u0581\u0582\u0005\u00cc\u0000"+
|
|
"\u0000\u0582\u05c3\u0001\u0000\u0000\u0000\u0583\u0584\u0005\u0014\u0000"+
|
|
"\u0000\u0584\u0585\u0005\u00cb\u0000\u0000\u0585\u058a\u0003\u0018\f\u0000"+
|
|
"\u0586\u0587\u0005\u00cd\u0000\u0000\u0587\u0589\u0003\u0018\f\u0000\u0588"+
|
|
"\u0586\u0001\u0000\u0000\u0000\u0589\u058c\u0001\u0000\u0000\u0000\u058a"+
|
|
"\u0588\u0001\u0000\u0000\u0000\u058a\u058b\u0001\u0000\u0000\u0000\u058b"+
|
|
"\u058d\u0001\u0000\u0000\u0000\u058c\u058a\u0001\u0000\u0000\u0000\u058d"+
|
|
"\u058e\u0005\u00cc\u0000\u0000\u058e\u05c3\u0001\u0000\u0000\u0000\u058f"+
|
|
"\u0590\u0005.\u0000\u0000\u0590\u0591\u0005\u00cb\u0000\u0000\u0591\u0594"+
|
|
"\u0003\u0018\f\u0000\u0592\u0593\u0005\u00cd\u0000\u0000\u0593\u0595\u0003"+
|
|
"\u0018\f\u0000\u0594\u0592\u0001\u0000\u0000\u0000\u0595\u0596\u0001\u0000"+
|
|
"\u0000\u0000\u0596\u0594\u0001\u0000\u0000\u0000\u0596\u0597\u0001\u0000"+
|
|
"\u0000\u0000\u0597\u0598\u0001\u0000\u0000\u0000\u0598\u0599\u0005\u00cc"+
|
|
"\u0000\u0000\u0599\u05c3\u0001\u0000\u0000\u0000\u059a\u059b\u0005/\u0000"+
|
|
"\u0000\u059b\u059c\u0005\u00cb\u0000\u0000\u059c\u059f\u0003\u0018\f\u0000"+
|
|
"\u059d\u059e\u0005\u00cd\u0000\u0000\u059e\u05a0\u0003\u0018\f\u0000\u059f"+
|
|
"\u059d\u0001\u0000\u0000\u0000\u05a0\u05a1\u0001\u0000\u0000\u0000\u05a1"+
|
|
"\u059f\u0001\u0000\u0000\u0000\u05a1\u05a2\u0001\u0000\u0000\u0000\u05a2"+
|
|
"\u05a3\u0001\u0000\u0000\u0000\u05a3\u05a4\u0005\u00cc\u0000\u0000\u05a4"+
|
|
"\u05c3\u0001\u0000\u0000\u0000\u05a5\u05a6\u00050\u0000\u0000\u05a6\u05a7"+
|
|
"\u0005\u00cb\u0000\u0000\u05a7\u05aa\u0003\u0018\f\u0000\u05a8\u05a9\u0005"+
|
|
"\u00cd\u0000\u0000\u05a9\u05ab\u0003\u0018\f\u0000\u05aa\u05a8\u0001\u0000"+
|
|
"\u0000\u0000\u05ab\u05ac\u0001\u0000\u0000\u0000\u05ac\u05aa\u0001\u0000"+
|
|
"\u0000\u0000\u05ac\u05ad\u0001\u0000\u0000\u0000\u05ad\u05ae\u0001\u0000"+
|
|
"\u0000\u0000\u05ae\u05af\u0005\u00cc\u0000\u0000\u05af\u05c3\u0001\u0000"+
|
|
"\u0000\u0000\u05b0\u05b1\u00053\u0000\u0000\u05b1\u05b2\u0005\u00cb\u0000"+
|
|
"\u0000\u05b2\u05b3\u0003\u0018\f\u0000\u05b3\u05b4\u0005\u00cd\u0000\u0000"+
|
|
"\u05b4\u05b5\u0003\u0018\f\u0000\u05b5\u05b6\u0005\u00cc\u0000\u0000\u05b6"+
|
|
"\u05c3\u0001\u0000\u0000\u0000\u05b7\u05b8\u0005s\u0000\u0000\u05b8\u05b9"+
|
|
"\u0005\u00cb\u0000\u0000\u05b9\u05bc\u0003\u0018\f\u0000\u05ba\u05bb\u0005"+
|
|
"\u00cd\u0000\u0000\u05bb\u05bd\u0003\u0018\f\u0000\u05bc\u05ba\u0001\u0000"+
|
|
"\u0000\u0000\u05bd\u05be\u0001\u0000\u0000\u0000\u05be\u05bc\u0001\u0000"+
|
|
"\u0000\u0000\u05be\u05bf\u0001\u0000\u0000\u0000\u05bf\u05c0\u0001\u0000"+
|
|
"\u0000\u0000\u05c0\u05c1\u0005\u00cc\u0000\u0000\u05c1\u05c3\u0001\u0000"+
|
|
"\u0000\u0000\u05c2\u0577\u0001\u0000\u0000\u0000\u05c2\u0583\u0001\u0000"+
|
|
"\u0000\u0000\u05c2\u058f\u0001\u0000\u0000\u0000\u05c2\u059a\u0001\u0000"+
|
|
"\u0000\u0000\u05c2\u05a5\u0001\u0000\u0000\u0000\u05c2\u05b0\u0001\u0000"+
|
|
"\u0000\u0000\u05c2\u05b7\u0001\u0000\u0000\u0000\u05c3;\u0001\u0000\u0000"+
|
|
"\u0000\u05c4\u05c5\u0005\u00a5\u0000\u0000\u05c5\u05c6\u0005\u00cb\u0000"+
|
|
"\u0000\u05c6\u05c9\u0003\u0018\f\u0000\u05c7\u05c8\u0005\u00cd\u0000\u0000"+
|
|
"\u05c8\u05ca\u0003\u0018\f\u0000\u05c9\u05c7\u0001\u0000\u0000\u0000\u05c9"+
|
|
"\u05ca\u0001\u0000\u0000\u0000\u05ca\u05cb\u0001\u0000\u0000\u0000\u05cb"+
|
|
"\u05cc\u0005\u00cc\u0000\u0000\u05cc\u06a2\u0001\u0000\u0000\u0000\u05cd"+
|
|
"\u05ce\u0005\u00a6\u0000\u0000\u05ce\u05cf\u0005\u00cb\u0000\u0000\u05cf"+
|
|
"\u05d2\u0003\u0018\f\u0000\u05d0\u05d1\u0005\u00cd\u0000\u0000\u05d1\u05d3"+
|
|
"\u0003\u0018\f\u0000\u05d2\u05d0\u0001\u0000\u0000\u0000\u05d2\u05d3\u0001"+
|
|
"\u0000\u0000\u0000\u05d3\u05d4\u0001\u0000\u0000\u0000\u05d4\u05d5\u0005"+
|
|
"\u00cc\u0000\u0000\u05d5\u06a2\u0001\u0000\u0000\u0000\u05d6\u05d7\u0005"+
|
|
"\u00a8\u0000\u0000\u05d7\u05d8\u0005\u00cb\u0000\u0000\u05d8\u05d9\u0003"+
|
|
"\u0018\f\u0000\u05d9\u05da\u0005\u00cd\u0000\u0000\u05da\u05dd\u0003\u0018"+
|
|
"\f\u0000\u05db\u05dc\u0005\u00cd\u0000\u0000\u05dc\u05de\u0003\u0018\f"+
|
|
"\u0000\u05dd\u05db\u0001\u0000\u0000\u0000\u05dd\u05de\u0001\u0000\u0000"+
|
|
"\u0000\u05de\u05df\u0001\u0000\u0000\u0000\u05df\u05e0\u0005\u00cc\u0000"+
|
|
"\u0000\u05e0\u06a2\u0001\u0000\u0000\u0000\u05e1\u05e2\u0005\u00aa\u0000"+
|
|
"\u0000\u05e2\u05e3\u0005\u00cb\u0000\u0000\u05e3\u05e4\u0003\u0018\f\u0000"+
|
|
"\u05e4\u05e5\u0005\u00cd\u0000\u0000\u05e5\u05e8\u0003\u0018\f\u0000\u05e6"+
|
|
"\u05e7\u0005\u00cd\u0000\u0000\u05e7\u05e9\u0003\u0018\f\u0000\u05e8\u05e6"+
|
|
"\u0001\u0000\u0000\u0000\u05e8\u05e9\u0001\u0000\u0000\u0000\u05e9\u05ea"+
|
|
"\u0001\u0000\u0000\u0000\u05ea\u05eb\u0005\u00cc\u0000\u0000\u05eb\u06a2"+
|
|
"\u0001\u0000\u0000\u0000\u05ec\u05ed\u0005\u00ab\u0000\u0000\u05ed\u05ee"+
|
|
"\u0005\u00cb\u0000\u0000\u05ee\u05ef\u0003\u0018\f\u0000\u05ef\u05f0\u0005"+
|
|
"\u00cd\u0000\u0000\u05f0\u05f3\u0003\u0018\f\u0000\u05f1\u05f2\u0005\u00cd"+
|
|
"\u0000\u0000\u05f2\u05f4\u0003\u0018\f\u0000\u05f3\u05f1\u0001\u0000\u0000"+
|
|
"\u0000\u05f3\u05f4\u0001\u0000\u0000\u0000\u05f4\u05f5\u0001\u0000\u0000"+
|
|
"\u0000\u05f5\u05f6\u0005\u00cc\u0000\u0000\u05f6\u06a2\u0001\u0000\u0000"+
|
|
"\u0000\u05f7\u05f8\u0005\u00a7\u0000\u0000\u05f8\u05f9\u0005\u00cb\u0000"+
|
|
"\u0000\u05f9\u05fa\u0003\u0018\f\u0000\u05fa\u05fb\u0005\u00cd\u0000\u0000"+
|
|
"\u05fb\u05fc\u0003\u0018\f\u0000\u05fc\u05fd\u0005\u00cd\u0000\u0000\u05fd"+
|
|
"\u0600\u0003\u0018\f\u0000\u05fe\u05ff\u0005\u00cd\u0000\u0000\u05ff\u0601"+
|
|
"\u0003\u0018\f\u0000\u0600\u05fe\u0001\u0000\u0000\u0000\u0600\u0601\u0001"+
|
|
"\u0000\u0000\u0000\u0601\u0602\u0001\u0000\u0000\u0000\u0602\u0603\u0005"+
|
|
"\u00cc\u0000\u0000\u0603\u06a2\u0001\u0000\u0000\u0000\u0604\u0605\u0005"+
|
|
"\u00a9\u0000\u0000\u0605\u0606\u0005\u00cb\u0000\u0000\u0606\u0607\u0003"+
|
|
"\u0018\f\u0000\u0607\u0608\u0005\u00cd\u0000\u0000\u0608\u0609\u0003\u0018"+
|
|
"\f\u0000\u0609\u060a\u0005\u00cd\u0000\u0000\u060a\u060d\u0003\u0018\f"+
|
|
"\u0000\u060b\u060c\u0005\u00cd\u0000\u0000\u060c\u060e\u0003\u0018\f\u0000"+
|
|
"\u060d\u060b\u0001\u0000\u0000\u0000\u060d\u060e\u0001\u0000\u0000\u0000"+
|
|
"\u060e\u060f\u0001\u0000\u0000\u0000\u060f\u0610\u0005\u00cc\u0000\u0000"+
|
|
"\u0610\u06a2\u0001\u0000\u0000\u0000\u0611\u0612\u0005\u00ac\u0000\u0000"+
|
|
"\u0612\u0613\u0005\u00cb\u0000\u0000\u0613\u0614\u0003\u0018\f\u0000\u0614"+
|
|
"\u0615\u0005\u00cd\u0000\u0000\u0615\u0616\u0003\u0018\f\u0000\u0616\u0617"+
|
|
"\u0005\u00cd\u0000\u0000\u0617\u061a\u0003\u0018\f\u0000\u0618\u0619\u0005"+
|
|
"\u00cd\u0000\u0000\u0619\u061b\u0003\u0018\f\u0000\u061a\u0618\u0001\u0000"+
|
|
"\u0000\u0000\u061a\u061b\u0001\u0000\u0000\u0000\u061b\u061c\u0001\u0000"+
|
|
"\u0000\u0000\u061c\u061d\u0005\u00cc\u0000\u0000\u061d\u06a2\u0001\u0000"+
|
|
"\u0000\u0000\u061e\u061f\u0005\u00ad\u0000\u0000\u061f\u0620\u0005\u00cb"+
|
|
"\u0000\u0000\u0620\u0621\u0003\u0018\f\u0000\u0621\u0622\u0005\u00cd\u0000"+
|
|
"\u0000\u0622\u0623\u0003\u0018\f\u0000\u0623\u0624\u0005\u00cd\u0000\u0000"+
|
|
"\u0624\u0627\u0003\u0018\f\u0000\u0625\u0626\u0005\u00cd\u0000\u0000\u0626"+
|
|
"\u0628\u0003\u0018\f\u0000\u0627\u0625\u0001\u0000\u0000\u0000\u0627\u0628"+
|
|
"\u0001\u0000\u0000\u0000\u0628\u0629\u0001\u0000\u0000\u0000\u0629\u062a"+
|
|
"\u0005\u00cc\u0000\u0000\u062a\u06a2\u0001\u0000\u0000\u0000\u062b\u062c"+
|
|
"\u0005\u00ae\u0000\u0000\u062c\u062d\u0005\u00cb\u0000\u0000\u062d\u062e"+
|
|
"\u0003\u0018\f\u0000\u062e\u062f\u0005\u00cd\u0000\u0000\u062f\u0630\u0003"+
|
|
"\u0018\f\u0000\u0630\u0631\u0005\u00cd\u0000\u0000\u0631\u0634\u0003\u0018"+
|
|
"\f\u0000\u0632\u0633\u0005\u00cd\u0000\u0000\u0633\u0635\u0003\u0018\f"+
|
|
"\u0000\u0634\u0632\u0001\u0000\u0000\u0000\u0634\u0635\u0001\u0000\u0000"+
|
|
"\u0000\u0635\u0636\u0001\u0000\u0000\u0000\u0636\u0637\u0005\u00cc\u0000"+
|
|
"\u0000\u0637\u06a2\u0001\u0000\u0000\u0000\u0638\u0639\u0005\u00af\u0000"+
|
|
"\u0000\u0639\u063a\u0005\u00cb\u0000\u0000\u063a\u063b\u0003\u0018\f\u0000"+
|
|
"\u063b\u063c\u0005\u00cd\u0000\u0000\u063c\u063d\u0003\u0018\f\u0000\u063d"+
|
|
"\u063e\u0005\u00cd\u0000\u0000\u063e\u0641\u0003\u0018\f\u0000\u063f\u0640"+
|
|
"\u0005\u00cd\u0000\u0000\u0640\u0642\u0003\u0018\f\u0000\u0641\u063f\u0001"+
|
|
"\u0000\u0000\u0000\u0641\u0642\u0001\u0000\u0000\u0000\u0642\u0643\u0001"+
|
|
"\u0000\u0000\u0000\u0643\u0644\u0005\u00cc\u0000\u0000\u0644\u06a2\u0001"+
|
|
"\u0000\u0000\u0000\u0645\u0646\u0005\u00b0\u0000\u0000\u0646\u0647\u0005"+
|
|
"\u00cb\u0000\u0000\u0647\u0648\u0003\u0018\f\u0000\u0648\u0649\u0005\u00cd"+
|
|
"\u0000\u0000\u0649\u064a\u0003\u0018\f\u0000\u064a\u064b\u0005\u00cd\u0000"+
|
|
"\u0000\u064b\u064e\u0003\u0018\f\u0000\u064c\u064d\u0005\u00cd\u0000\u0000"+
|
|
"\u064d\u064f\u0003\u0018\f\u0000\u064e\u064c\u0001\u0000\u0000\u0000\u064e"+
|
|
"\u064f\u0001\u0000\u0000\u0000\u064f\u0650\u0001\u0000\u0000\u0000\u0650"+
|
|
"\u0651\u0005\u00cc\u0000\u0000\u0651\u06a2\u0001\u0000\u0000\u0000\u0652"+
|
|
"\u0653\u0005\u00b1\u0000\u0000\u0653\u0654\u0005\u00cb\u0000\u0000\u0654"+
|
|
"\u0655\u0003\u0018\f\u0000\u0655\u0656\u0005\u00cd\u0000\u0000\u0656\u0659"+
|
|
"\u0003\u0018\f\u0000\u0657\u0658\u0005\u00cd\u0000\u0000\u0658\u065a\u0003"+
|
|
"\u0018\f\u0000\u0659\u0657\u0001\u0000\u0000\u0000\u0659\u065a\u0001\u0000"+
|
|
"\u0000\u0000\u065a\u065b\u0001\u0000\u0000\u0000\u065b\u065c\u0005\u00cc"+
|
|
"\u0000\u0000\u065c\u06a2\u0001\u0000\u0000\u0000\u065d\u065e\u0005\u00b2"+
|
|
"\u0000\u0000\u065e\u065f\u0005\u00cb\u0000\u0000\u065f\u0660\u0003\u0018"+
|
|
"\f\u0000\u0660\u0661\u0005\u00cd\u0000\u0000\u0661\u0664\u0003\u0018\f"+
|
|
"\u0000\u0662\u0663\u0005\u00cd\u0000\u0000\u0663\u0665\u0003\u0018\f\u0000"+
|
|
"\u0664\u0662\u0001\u0000\u0000\u0000\u0664\u0665\u0001\u0000\u0000\u0000"+
|
|
"\u0665\u0666\u0001\u0000\u0000\u0000\u0666\u0667\u0005\u00cc\u0000\u0000"+
|
|
"\u0667\u06a2\u0001\u0000\u0000\u0000\u0668\u0669\u0005\u00b3\u0000\u0000"+
|
|
"\u0669\u066a\u0005\u00cb\u0000\u0000\u066a\u066b\u0003\u0018\f\u0000\u066b"+
|
|
"\u066c\u0005\u00cd\u0000\u0000\u066c\u066f\u0003\u0018\f\u0000\u066d\u066e"+
|
|
"\u0005\u00cd\u0000\u0000\u066e\u0670\u0003\u0018\f\u0000\u066f\u066d\u0001"+
|
|
"\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000\u0000\u0670\u0673\u0001"+
|
|
"\u0000\u0000\u0000\u0671\u0672\u0005\u00cd\u0000\u0000\u0672\u0674\u0003"+
|
|
"\u0018\f\u0000\u0673\u0671\u0001\u0000\u0000\u0000\u0673\u0674\u0001\u0000"+
|
|
"\u0000\u0000\u0674\u0677\u0001\u0000\u0000\u0000\u0675\u0676\u0005\u00cd"+
|
|
"\u0000\u0000\u0676\u0678\u0003\u0018\f\u0000\u0677\u0675\u0001\u0000\u0000"+
|
|
"\u0000\u0677\u0678\u0001\u0000\u0000\u0000\u0678\u0679\u0001\u0000\u0000"+
|
|
"\u0000\u0679\u067a\u0005\u00cc\u0000\u0000\u067a\u06a2\u0001\u0000\u0000"+
|
|
"\u0000\u067b\u067c\u0005\u00b4\u0000\u0000\u067c\u067d\u0005\u00cb\u0000"+
|
|
"\u0000\u067d\u067e\u0003\u0018\f\u0000\u067e\u067f\u0005\u00cd\u0000\u0000"+
|
|
"\u067f\u0682\u0003\u0018\f\u0000\u0680\u0681\u0005\u00cd\u0000\u0000\u0681"+
|
|
"\u0683\u0003\u0018\f\u0000\u0682\u0680\u0001\u0000\u0000\u0000\u0682\u0683"+
|
|
"\u0001\u0000\u0000\u0000\u0683\u0686\u0001\u0000\u0000\u0000\u0684\u0685"+
|
|
"\u0005\u00cd\u0000\u0000\u0685\u0687\u0003\u0018\f\u0000\u0686\u0684\u0001"+
|
|
"\u0000\u0000\u0000\u0686\u0687\u0001\u0000\u0000\u0000\u0687\u068a\u0001"+
|
|
"\u0000\u0000\u0000\u0688\u0689\u0005\u00cd\u0000\u0000\u0689\u068b\u0003"+
|
|
"\u0018\f\u0000\u068a\u0688\u0001\u0000\u0000\u0000\u068a\u068b\u0001\u0000"+
|
|
"\u0000\u0000\u068b\u068c\u0001\u0000\u0000\u0000\u068c\u068d\u0005\u00cc"+
|
|
"\u0000\u0000\u068d\u06a2\u0001\u0000\u0000\u0000\u068e\u068f\u0005\u00b5"+
|
|
"\u0000\u0000\u068f\u0690\u0005\u00cb\u0000\u0000\u0690\u0691\u0003\u0018"+
|
|
"\f\u0000\u0691\u0692\u0005\u00cd\u0000\u0000\u0692\u0695\u0003\u0018\f"+
|
|
"\u0000\u0693\u0694\u0005\u00cd\u0000\u0000\u0694\u0696\u0003\u0018\f\u0000"+
|
|
"\u0695\u0693\u0001\u0000\u0000\u0000\u0695\u0696\u0001\u0000\u0000\u0000"+
|
|
"\u0696\u0699\u0001\u0000\u0000\u0000\u0697\u0698\u0005\u00cd\u0000\u0000"+
|
|
"\u0698\u069a\u0003\u0018\f\u0000\u0699\u0697\u0001\u0000\u0000\u0000\u0699"+
|
|
"\u069a\u0001\u0000\u0000\u0000\u069a\u069d\u0001\u0000\u0000\u0000\u069b"+
|
|
"\u069c\u0005\u00cd\u0000\u0000\u069c\u069e\u0003\u0018\f\u0000\u069d\u069b"+
|
|
"\u0001\u0000\u0000\u0000\u069d\u069e\u0001\u0000\u0000\u0000\u069e\u069f"+
|
|
"\u0001\u0000\u0000\u0000\u069f\u06a0\u0005\u00cc\u0000\u0000\u06a0\u06a2"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u05c4\u0001\u0000\u0000\u0000\u06a1\u05cd"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u05d6\u0001\u0000\u0000\u0000\u06a1\u05e1"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u05ec\u0001\u0000\u0000\u0000\u06a1\u05f7"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u0604\u0001\u0000\u0000\u0000\u06a1\u0611"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u061e\u0001\u0000\u0000\u0000\u06a1\u062b"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u0638\u0001\u0000\u0000\u0000\u06a1\u0645"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u0652\u0001\u0000\u0000\u0000\u06a1\u065d"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u0668\u0001\u0000\u0000\u0000\u06a1\u067b"+
|
|
"\u0001\u0000\u0000\u0000\u06a1\u068e\u0001\u0000\u0000\u0000\u06a2=\u0001"+
|
|
"\u0000\u0000\u0000^ACHOU`gs\u0081\u008a\u009e\u00ab\u00b2\u00cf\u00d1"+
|
|
"\u00dd\u00df\u00ee\u00f0\u00fc\u00fe\u0106\u010d\u0119\u0120\u013d\u0145"+
|
|
"\u014b\u0152\u0226\u025c\u026f\u0278\u02c7\u02d0\u02d9\u02e2\u02fa\u037a"+
|
|
"\u03a8\u03aa\u03d5\u03d7\u03d9\u03f7\u0400\u040b\u0416\u0437\u0450\u04b1"+
|
|
"\u04be\u04d2\u04de\u04ea\u04f6\u04fa\u0506\u050a\u051f\u052b\u052f\u0568"+
|
|
"\u057e\u058a\u0596\u05a1\u05ac\u05be\u05c2\u05c9\u05d2\u05dd\u05e8\u05f3"+
|
|
"\u0600\u060d\u061a\u0627\u0634\u0641\u064e\u0659\u0664\u066f\u0673\u0677"+
|
|
"\u0682\u0686\u068a\u0695\u0699\u069d\u06a1";
|
|
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);
|
|
}
|
|
}
|
|
} |