3857 lines
122 KiB
Java
3857 lines
122 KiB
Java
// Generated from d:\stability\Data\Packages\ComfyUI\custom_nodes\more_math\more_math\Parser\MathExpr.g4 by ANTLR 4.9.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"})
|
|
public class MathExprParser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.9.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, LERP=37, STEP=38, SMOOTHSTEP=39, FRACT=40,
|
|
RELU=41, SOFTPLUS=42, GELU=43, SIGN=44, MAP=45, EZCONV=46, CONV=47, SWAP=48,
|
|
PERM=49, RESHAPE=50, RANGE=51, TOPK=52, BOTK=53, PINV=54, SUM=55, MEAN=56,
|
|
STD=57, VAR=58, QUARTILE=59, PERCENTILE=60, QUANTILE=61, DOT=62, MOMENT=63,
|
|
COSSIM=64, FLIP=65, COV=66, SORT=67, APPEND=68, PLUS=69, MINUS=70, MULT=71,
|
|
DIV=72, MOD=73, POW=74, GE=75, GT=76, LE=77, LT=78, EQ=79, NE=80, PIPE=81,
|
|
LPAREN=82, RPAREN=83, COMMA=84, SEMICOLON=85, ARROW=86, LBRACKET=87, RBRACKET=88,
|
|
CONSTANT=89, NUMBER=90, VARIABLE=91, WS=92;
|
|
public static final int
|
|
RULE_start = 0, RULE_funcDef = 1, RULE_paramList = 2, RULE_expr = 3, RULE_compExpr = 4,
|
|
RULE_addExpr = 5, RULE_mulExpr = 6, RULE_powExpr = 7, RULE_unaryExpr = 8,
|
|
RULE_indexExpr = 9, RULE_atom = 10, RULE_exprList = 11, RULE_func1 = 12,
|
|
RULE_func2 = 13, RULE_func3 = 14, RULE_func4 = 15, RULE_funcN = 16;
|
|
private static String[] makeRuleNames() {
|
|
return new String[] {
|
|
"start", "funcDef", "paramList", "expr", "compExpr", "addExpr", "mulExpr",
|
|
"powExpr", "unaryExpr", "indexExpr", "atom", "exprList", "func1", "func2",
|
|
"func3", "func4", "funcN"
|
|
};
|
|
}
|
|
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, "'lerp'",
|
|
"'step'", "'smoothstep'", "'fract'", "'relu'", "'softplus'", "'gelu'",
|
|
"'sign'", "'map'", null, null, "'swap'", null, null, "'range'", "'topk'",
|
|
"'botk'", "'pinv'", "'sum'", "'mean'", "'std'", "'var'", null, null,
|
|
"'quantile'", "'dot'", "'moment'", "'cossim'", "'flip'", "'cov'", "'sort'",
|
|
"'append'", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'>='", "'>'",
|
|
"'<='", "'<'", "'=='", "'!='", "'|'", "'('", "')'", "','", "';'", "'->'",
|
|
"'['", "']'"
|
|
};
|
|
}
|
|
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",
|
|
"LERP", "STEP", "SMOOTHSTEP", "FRACT", "RELU", "SOFTPLUS", "GELU", "SIGN",
|
|
"MAP", "EZCONV", "CONV", "SWAP", "PERM", "RESHAPE", "RANGE", "TOPK",
|
|
"BOTK", "PINV", "SUM", "MEAN", "STD", "VAR", "QUARTILE", "PERCENTILE",
|
|
"QUANTILE", "DOT", "MOMENT", "COSSIM", "FLIP", "COV", "SORT", "APPEND",
|
|
"PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", "LT",
|
|
"EQ", "NE", "PIPE", "LPAREN", "RPAREN", "COMMA", "SEMICOLON", "ARROW",
|
|
"LBRACKET", "RBRACKET", "CONSTANT", "NUMBER", "VARIABLE", "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);
|
|
}
|
|
|
|
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 StartContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_start; }
|
|
}
|
|
|
|
public final StartContext start() throws RecognitionException {
|
|
StartContext _localctx = new StartContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_start);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(37);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(34);
|
|
funcDef();
|
|
}
|
|
}
|
|
}
|
|
setState(39);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
|
|
}
|
|
setState(40);
|
|
expr();
|
|
setState(41);
|
|
match(EOF);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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 ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode SEMICOLON() { return getToken(MathExprParser.SEMICOLON, 0); }
|
|
public ParamListContext paramList() {
|
|
return getRuleContext(ParamListContext.class,0);
|
|
}
|
|
public FunctionDefContext(FuncDefContext ctx) { copyFrom(ctx); }
|
|
}
|
|
|
|
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(43);
|
|
match(VARIABLE);
|
|
setState(44);
|
|
match(LPAREN);
|
|
setState(46);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==VARIABLE) {
|
|
{
|
|
setState(45);
|
|
paramList();
|
|
}
|
|
}
|
|
|
|
setState(48);
|
|
match(RPAREN);
|
|
setState(49);
|
|
match(ARROW);
|
|
setState(50);
|
|
expr();
|
|
setState(51);
|
|
match(SEMICOLON);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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; }
|
|
}
|
|
|
|
public final ParamListContext paramList() throws RecognitionException {
|
|
ParamListContext _localctx = new ParamListContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_paramList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(53);
|
|
match(VARIABLE);
|
|
setState(58);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(54);
|
|
match(COMMA);
|
|
setState(55);
|
|
match(VARIABLE);
|
|
}
|
|
}
|
|
setState(60);
|
|
_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;
|
|
}
|
|
|
|
public static class ExprContext extends ParserRuleContext {
|
|
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; }
|
|
}
|
|
|
|
public final ExprContext expr() throws RecognitionException {
|
|
ExprContext _localctx = new ExprContext(_ctx, getState());
|
|
enterRule(_localctx, 6, RULE_expr);
|
|
try {
|
|
setState(63);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(61);
|
|
atom();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(62);
|
|
compExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class ToAddContext extends CompExprContext {
|
|
public AddExprContext addExpr() {
|
|
return getRuleContext(AddExprContext.class,0);
|
|
}
|
|
public ToAddContext(CompExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
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 = 8;
|
|
enterRecursionRule(_localctx, 8, RULE_compExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToAddContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(66);
|
|
addExpr(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(88);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(86);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new GtExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(68);
|
|
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(69);
|
|
match(GT);
|
|
setState(70);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new GeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(71);
|
|
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(72);
|
|
match(GE);
|
|
setState(73);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new LtExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(74);
|
|
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(75);
|
|
match(LT);
|
|
setState(76);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new LeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(77);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(78);
|
|
match(LE);
|
|
setState(79);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new EqExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(80);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(81);
|
|
match(EQ);
|
|
setState(82);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new NeExpContext(new CompExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_compExpr);
|
|
setState(83);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(84);
|
|
match(NE);
|
|
setState(85);
|
|
addExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(90);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
public static class ToMulContext extends AddExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public ToMulContext(AddExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
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 = 10;
|
|
enterRecursionRule(_localctx, 10, RULE_addExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToMulContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(92);
|
|
mulExpr(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(102);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(100);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new AddExpContext(new AddExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_addExpr);
|
|
setState(94);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(95);
|
|
match(PLUS);
|
|
setState(96);
|
|
mulExpr(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new SubExpContext(new AddExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_addExpr);
|
|
setState(97);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(98);
|
|
match(MINUS);
|
|
setState(99);
|
|
mulExpr(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(104);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
public static class MulExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode MULT() { return getToken(MathExprParser.MULT, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public MulExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class ModExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode MOD() { return getToken(MathExprParser.MOD, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public ModExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class DivExpContext extends MulExprContext {
|
|
public MulExprContext mulExpr() {
|
|
return getRuleContext(MulExprContext.class,0);
|
|
}
|
|
public TerminalNode DIV() { return getToken(MathExprParser.DIV, 0); }
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public DivExpContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class ToPowContext extends MulExprContext {
|
|
public PowExprContext powExpr() {
|
|
return getRuleContext(PowExprContext.class,0);
|
|
}
|
|
public ToPowContext(MulExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
|
|
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 = 12;
|
|
enterRecursionRule(_localctx, 12, RULE_mulExpr, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToPowContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(106);
|
|
powExpr();
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(119);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(117);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new MulExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(108);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(109);
|
|
match(MULT);
|
|
setState(110);
|
|
powExpr();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new DivExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(111);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(112);
|
|
match(DIV);
|
|
setState(113);
|
|
powExpr();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new ModExpContext(new MulExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_mulExpr);
|
|
setState(114);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(115);
|
|
match(MOD);
|
|
setState(116);
|
|
powExpr();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(121);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
public static class ToUnaryContext extends PowExprContext {
|
|
public UnaryExprContext unaryExpr() {
|
|
return getRuleContext(UnaryExprContext.class,0);
|
|
}
|
|
public ToUnaryContext(PowExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
|
|
public final PowExprContext powExpr() throws RecognitionException {
|
|
PowExprContext _localctx = new PowExprContext(_ctx, getState());
|
|
enterRule(_localctx, 14, RULE_powExpr);
|
|
try {
|
|
setState(127);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
|
|
case 1:
|
|
_localctx = new PowExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(122);
|
|
unaryExpr();
|
|
setState(123);
|
|
match(POW);
|
|
setState(124);
|
|
powExpr();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new ToUnaryContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(126);
|
|
unaryExpr();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class ToIndexContext extends UnaryExprContext {
|
|
public IndexExprContext indexExpr() {
|
|
return getRuleContext(IndexExprContext.class,0);
|
|
}
|
|
public ToIndexContext(UnaryExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
|
|
public final UnaryExprContext unaryExpr() throws RecognitionException {
|
|
UnaryExprContext _localctx = new UnaryExprContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_unaryExpr);
|
|
try {
|
|
setState(134);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case PLUS:
|
|
_localctx = new UnaryPlusContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(129);
|
|
match(PLUS);
|
|
setState(130);
|
|
unaryExpr();
|
|
}
|
|
break;
|
|
case MINUS:
|
|
_localctx = new UnaryMinusContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(131);
|
|
match(MINUS);
|
|
setState(132);
|
|
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 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 TOPK:
|
|
case BOTK:
|
|
case PINV:
|
|
case SUM:
|
|
case MEAN:
|
|
case STD:
|
|
case VAR:
|
|
case QUARTILE:
|
|
case PERCENTILE:
|
|
case QUANTILE:
|
|
case DOT:
|
|
case MOMENT:
|
|
case COSSIM:
|
|
case FLIP:
|
|
case COV:
|
|
case SORT:
|
|
case APPEND:
|
|
case PIPE:
|
|
case LPAREN:
|
|
case LBRACKET:
|
|
case CONSTANT:
|
|
case NUMBER:
|
|
case VARIABLE:
|
|
_localctx = new ToIndexContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(133);
|
|
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;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
public static class ToAtomContext extends IndexExprContext {
|
|
public AtomContext atom() {
|
|
return getRuleContext(AtomContext.class,0);
|
|
}
|
|
public ToAtomContext(IndexExprContext ctx) { copyFrom(ctx); }
|
|
}
|
|
|
|
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 = 18;
|
|
enterRecursionRule(_localctx, 18, RULE_indexExpr, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
_localctx = new ToAtomContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(137);
|
|
atom();
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(153);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,13,_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(139);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(140);
|
|
match(LBRACKET);
|
|
setState(141);
|
|
expr();
|
|
setState(146);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(142);
|
|
match(COMMA);
|
|
setState(143);
|
|
expr();
|
|
}
|
|
}
|
|
setState(148);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(149);
|
|
match(RBRACKET);
|
|
}
|
|
}
|
|
}
|
|
setState(155);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
public static class Func4ExpContext extends AtomContext {
|
|
public Func4Context func4() {
|
|
return getRuleContext(Func4Context.class,0);
|
|
}
|
|
public Func4ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class Func2ExpContext extends AtomContext {
|
|
public Func2Context func2() {
|
|
return getRuleContext(Func2Context.class,0);
|
|
}
|
|
public Func2ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class VariableExpContext extends AtomContext {
|
|
public TerminalNode VARIABLE() { return getToken(MathExprParser.VARIABLE, 0); }
|
|
public VariableExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class Func3ExpContext extends AtomContext {
|
|
public Func3Context func3() {
|
|
return getRuleContext(Func3Context.class,0);
|
|
}
|
|
public Func3ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class ConstantExpContext extends AtomContext {
|
|
public TerminalNode CONSTANT() { return getToken(MathExprParser.CONSTANT, 0); }
|
|
public ConstantExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class Func1ExpContext extends AtomContext {
|
|
public Func1Context func1() {
|
|
return getRuleContext(Func1Context.class,0);
|
|
}
|
|
public Func1ExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class FuncNExpContext extends AtomContext {
|
|
public FuncNContext funcN() {
|
|
return getRuleContext(FuncNContext.class,0);
|
|
}
|
|
public FuncNExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
public static class NumberExpContext extends AtomContext {
|
|
public TerminalNode NUMBER() { return getToken(MathExprParser.NUMBER, 0); }
|
|
public NumberExpContext(AtomContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final AtomContext atom() throws RecognitionException {
|
|
AtomContext _localctx = new AtomContext(_ctx, getState());
|
|
enterRule(_localctx, 20, RULE_atom);
|
|
int _la;
|
|
try {
|
|
setState(189);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
|
|
case 1:
|
|
_localctx = new Func1ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(156);
|
|
func1();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new Func2ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(157);
|
|
func2();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new Func3ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(158);
|
|
func3();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new Func4ExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(159);
|
|
func4();
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new FuncNExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(160);
|
|
funcN();
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new VariableExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(161);
|
|
match(VARIABLE);
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new NumberExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(162);
|
|
match(NUMBER);
|
|
}
|
|
break;
|
|
case 8:
|
|
_localctx = new ConstantExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(163);
|
|
match(CONSTANT);
|
|
}
|
|
break;
|
|
case 9:
|
|
_localctx = new ParenExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(164);
|
|
match(LPAREN);
|
|
setState(165);
|
|
expr();
|
|
setState(166);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 10:
|
|
_localctx = new AbsExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(168);
|
|
match(PIPE);
|
|
setState(169);
|
|
expr();
|
|
setState(170);
|
|
match(PIPE);
|
|
}
|
|
break;
|
|
case 11:
|
|
_localctx = new ListExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(172);
|
|
match(LBRACKET);
|
|
setState(173);
|
|
expr();
|
|
setState(178);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(174);
|
|
match(COMMA);
|
|
setState(175);
|
|
expr();
|
|
}
|
|
}
|
|
setState(180);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(181);
|
|
match(RBRACKET);
|
|
}
|
|
break;
|
|
case 12:
|
|
_localctx = new CallExpContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(183);
|
|
match(VARIABLE);
|
|
setState(184);
|
|
match(LPAREN);
|
|
setState(186);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SIN) | (1L << COS) | (1L << TAN) | (1L << ASIN) | (1L << ACOS) | (1L << ATAN) | (1L << ATAN2) | (1L << SINH) | (1L << COSH) | (1L << TANH) | (1L << ASINH) | (1L << ACOSH) | (1L << ATANH) | (1L << ABS) | (1L << SQRT) | (1L << LN) | (1L << LOG) | (1L << EXP) | (1L << SMIN) | (1L << SMAX) | (1L << TMIN) | (1L << TMAX) | (1L << TNORM) | (1L << SNORM) | (1L << FLOOR) | (1L << CEIL) | (1L << ROUND) | (1L << GAMMA) | (1L << POWE) | (1L << SIGM) | (1L << CLAMP) | (1L << SFFT) | (1L << SIFFT) | (1L << ANGL) | (1L << PRNT) | (1L << PRINT_SHAPE) | (1L << LERP) | (1L << STEP) | (1L << SMOOTHSTEP) | (1L << FRACT) | (1L << RELU) | (1L << SOFTPLUS) | (1L << GELU) | (1L << SIGN) | (1L << MAP) | (1L << EZCONV) | (1L << CONV) | (1L << SWAP) | (1L << PERM) | (1L << RESHAPE) | (1L << RANGE) | (1L << TOPK) | (1L << BOTK) | (1L << PINV) | (1L << SUM) | (1L << MEAN) | (1L << STD) | (1L << VAR) | (1L << QUARTILE) | (1L << PERCENTILE) | (1L << QUANTILE) | (1L << DOT) | (1L << MOMENT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COSSIM - 64)) | (1L << (FLIP - 64)) | (1L << (COV - 64)) | (1L << (SORT - 64)) | (1L << (APPEND - 64)) | (1L << (PLUS - 64)) | (1L << (MINUS - 64)) | (1L << (PIPE - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACKET - 64)) | (1L << (CONSTANT - 64)) | (1L << (NUMBER - 64)) | (1L << (VARIABLE - 64)))) != 0)) {
|
|
{
|
|
setState(185);
|
|
exprList();
|
|
}
|
|
}
|
|
|
|
setState(188);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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; }
|
|
}
|
|
|
|
public final ExprListContext exprList() throws RecognitionException {
|
|
ExprListContext _localctx = new ExprListContext(_ctx, getState());
|
|
enterRule(_localctx, 22, RULE_exprList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(191);
|
|
expr();
|
|
setState(196);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(192);
|
|
match(COMMA);
|
|
setState(193);
|
|
expr();
|
|
}
|
|
}
|
|
setState(198);
|
|
_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;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class SifftFuncContext extends Func1Context {
|
|
public TerminalNode SIFFT() { return getToken(MathExprParser.SIFFT, 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 SifftFuncContext(Func1Context ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final Func1Context func1() throws RecognitionException {
|
|
Func1Context _localctx = new Func1Context(_ctx, getState());
|
|
enterRule(_localctx, 24, RULE_func1);
|
|
try {
|
|
setState(399);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SIN:
|
|
_localctx = new SinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(199);
|
|
match(SIN);
|
|
setState(200);
|
|
match(LPAREN);
|
|
setState(201);
|
|
expr();
|
|
setState(202);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COS:
|
|
_localctx = new CosFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(204);
|
|
match(COS);
|
|
setState(205);
|
|
match(LPAREN);
|
|
setState(206);
|
|
expr();
|
|
setState(207);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TAN:
|
|
_localctx = new TanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(209);
|
|
match(TAN);
|
|
setState(210);
|
|
match(LPAREN);
|
|
setState(211);
|
|
expr();
|
|
setState(212);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ASIN:
|
|
_localctx = new AsinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(214);
|
|
match(ASIN);
|
|
setState(215);
|
|
match(LPAREN);
|
|
setState(216);
|
|
expr();
|
|
setState(217);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ACOS:
|
|
_localctx = new AcosFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(219);
|
|
match(ACOS);
|
|
setState(220);
|
|
match(LPAREN);
|
|
setState(221);
|
|
expr();
|
|
setState(222);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ATAN:
|
|
_localctx = new AtanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(224);
|
|
match(ATAN);
|
|
setState(225);
|
|
match(LPAREN);
|
|
setState(226);
|
|
expr();
|
|
setState(227);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SINH:
|
|
_localctx = new SinhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(229);
|
|
match(SINH);
|
|
setState(230);
|
|
match(LPAREN);
|
|
setState(231);
|
|
expr();
|
|
setState(232);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case COSH:
|
|
_localctx = new CoshFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(234);
|
|
match(COSH);
|
|
setState(235);
|
|
match(LPAREN);
|
|
setState(236);
|
|
expr();
|
|
setState(237);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TANH:
|
|
_localctx = new TanhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(239);
|
|
match(TANH);
|
|
setState(240);
|
|
match(LPAREN);
|
|
setState(241);
|
|
expr();
|
|
setState(242);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ASINH:
|
|
_localctx = new AsinhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(244);
|
|
match(ASINH);
|
|
setState(245);
|
|
match(LPAREN);
|
|
setState(246);
|
|
expr();
|
|
setState(247);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ACOSH:
|
|
_localctx = new AcoshFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(249);
|
|
match(ACOSH);
|
|
setState(250);
|
|
match(LPAREN);
|
|
setState(251);
|
|
expr();
|
|
setState(252);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ATANH:
|
|
_localctx = new AtanhFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(254);
|
|
match(ATANH);
|
|
setState(255);
|
|
match(LPAREN);
|
|
setState(256);
|
|
expr();
|
|
setState(257);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ABS:
|
|
_localctx = new AbsFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(259);
|
|
match(ABS);
|
|
setState(260);
|
|
match(LPAREN);
|
|
setState(261);
|
|
expr();
|
|
setState(262);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SQRT:
|
|
_localctx = new SqrtFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(264);
|
|
match(SQRT);
|
|
setState(265);
|
|
match(LPAREN);
|
|
setState(266);
|
|
expr();
|
|
setState(267);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LN:
|
|
_localctx = new LnFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(269);
|
|
match(LN);
|
|
setState(270);
|
|
match(LPAREN);
|
|
setState(271);
|
|
expr();
|
|
setState(272);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LOG:
|
|
_localctx = new LogFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(274);
|
|
match(LOG);
|
|
setState(275);
|
|
match(LPAREN);
|
|
setState(276);
|
|
expr();
|
|
setState(277);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EXP:
|
|
_localctx = new ExpFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(279);
|
|
match(EXP);
|
|
setState(280);
|
|
match(LPAREN);
|
|
setState(281);
|
|
expr();
|
|
setState(282);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case TNORM:
|
|
_localctx = new TNormFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(284);
|
|
match(TNORM);
|
|
setState(285);
|
|
match(LPAREN);
|
|
setState(286);
|
|
expr();
|
|
setState(287);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SNORM:
|
|
_localctx = new SNormFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 19);
|
|
{
|
|
setState(289);
|
|
match(SNORM);
|
|
setState(290);
|
|
match(LPAREN);
|
|
setState(291);
|
|
expr();
|
|
setState(292);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FLOOR:
|
|
_localctx = new FloorFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 20);
|
|
{
|
|
setState(294);
|
|
match(FLOOR);
|
|
setState(295);
|
|
match(LPAREN);
|
|
setState(296);
|
|
expr();
|
|
setState(297);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CEIL:
|
|
_localctx = new CeilFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 21);
|
|
{
|
|
setState(299);
|
|
match(CEIL);
|
|
setState(300);
|
|
match(LPAREN);
|
|
setState(301);
|
|
expr();
|
|
setState(302);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ROUND:
|
|
_localctx = new RoundFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 22);
|
|
{
|
|
setState(304);
|
|
match(ROUND);
|
|
setState(305);
|
|
match(LPAREN);
|
|
setState(306);
|
|
expr();
|
|
setState(307);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GAMMA:
|
|
_localctx = new GammaFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 23);
|
|
{
|
|
setState(309);
|
|
match(GAMMA);
|
|
setState(310);
|
|
match(LPAREN);
|
|
setState(311);
|
|
expr();
|
|
setState(312);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIGM:
|
|
_localctx = new SigmoidFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 24);
|
|
{
|
|
setState(314);
|
|
match(SIGM);
|
|
setState(315);
|
|
match(LPAREN);
|
|
setState(316);
|
|
expr();
|
|
setState(317);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SFFT:
|
|
_localctx = new SfftFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 25);
|
|
{
|
|
setState(319);
|
|
match(SFFT);
|
|
setState(320);
|
|
match(LPAREN);
|
|
setState(321);
|
|
expr();
|
|
setState(322);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIFFT:
|
|
_localctx = new SifftFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 26);
|
|
{
|
|
setState(324);
|
|
match(SIFFT);
|
|
setState(325);
|
|
match(LPAREN);
|
|
setState(326);
|
|
expr();
|
|
setState(327);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case ANGL:
|
|
_localctx = new AnglFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 27);
|
|
{
|
|
setState(329);
|
|
match(ANGL);
|
|
setState(330);
|
|
match(LPAREN);
|
|
setState(331);
|
|
expr();
|
|
setState(332);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PRNT:
|
|
_localctx = new PrintFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 28);
|
|
{
|
|
setState(334);
|
|
match(PRNT);
|
|
setState(335);
|
|
match(LPAREN);
|
|
setState(336);
|
|
expr();
|
|
setState(337);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case FRACT:
|
|
_localctx = new FractFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 29);
|
|
{
|
|
setState(339);
|
|
match(FRACT);
|
|
setState(340);
|
|
match(LPAREN);
|
|
setState(341);
|
|
expr();
|
|
setState(342);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RELU:
|
|
_localctx = new ReluFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 30);
|
|
{
|
|
setState(344);
|
|
match(RELU);
|
|
setState(345);
|
|
match(LPAREN);
|
|
setState(346);
|
|
expr();
|
|
setState(347);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SOFTPLUS:
|
|
_localctx = new SoftplusFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 31);
|
|
{
|
|
setState(349);
|
|
match(SOFTPLUS);
|
|
setState(350);
|
|
match(LPAREN);
|
|
setState(351);
|
|
expr();
|
|
setState(352);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case GELU:
|
|
_localctx = new GeluFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 32);
|
|
{
|
|
setState(354);
|
|
match(GELU);
|
|
setState(355);
|
|
match(LPAREN);
|
|
setState(356);
|
|
expr();
|
|
setState(357);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SIGN:
|
|
_localctx = new SignFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 33);
|
|
{
|
|
setState(359);
|
|
match(SIGN);
|
|
setState(360);
|
|
match(LPAREN);
|
|
setState(361);
|
|
expr();
|
|
setState(362);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PRINT_SHAPE:
|
|
_localctx = new PrintShapeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 34);
|
|
{
|
|
setState(364);
|
|
match(PRINT_SHAPE);
|
|
setState(365);
|
|
match(LPAREN);
|
|
setState(366);
|
|
expr();
|
|
setState(367);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PINV:
|
|
_localctx = new PinvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 35);
|
|
{
|
|
setState(369);
|
|
match(PINV);
|
|
setState(370);
|
|
match(LPAREN);
|
|
setState(371);
|
|
expr();
|
|
setState(372);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SUM:
|
|
_localctx = new SumFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 36);
|
|
{
|
|
setState(374);
|
|
match(SUM);
|
|
setState(375);
|
|
match(LPAREN);
|
|
setState(376);
|
|
expr();
|
|
setState(377);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MEAN:
|
|
_localctx = new MeanFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 37);
|
|
{
|
|
setState(379);
|
|
match(MEAN);
|
|
setState(380);
|
|
match(LPAREN);
|
|
setState(381);
|
|
expr();
|
|
setState(382);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case STD:
|
|
_localctx = new StdFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 38);
|
|
{
|
|
setState(384);
|
|
match(STD);
|
|
setState(385);
|
|
match(LPAREN);
|
|
setState(386);
|
|
expr();
|
|
setState(387);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case VAR:
|
|
_localctx = new VarFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 39);
|
|
{
|
|
setState(389);
|
|
match(VAR);
|
|
setState(390);
|
|
match(LPAREN);
|
|
setState(391);
|
|
expr();
|
|
setState(392);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SORT:
|
|
_localctx = new SortFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 40);
|
|
{
|
|
setState(394);
|
|
match(SORT);
|
|
setState(395);
|
|
match(LPAREN);
|
|
setState(396);
|
|
expr();
|
|
setState(397);
|
|
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 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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final Func2Context func2() throws RecognitionException {
|
|
Func2Context _localctx = new Func2Context(_ctx, getState());
|
|
enterRule(_localctx, 26, RULE_func2);
|
|
try {
|
|
setState(513);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
|
|
case 1:
|
|
_localctx = new PowFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(401);
|
|
match(POWE);
|
|
setState(402);
|
|
match(LPAREN);
|
|
setState(403);
|
|
expr();
|
|
setState(404);
|
|
match(COMMA);
|
|
setState(405);
|
|
expr();
|
|
setState(406);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new Atan2FuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(408);
|
|
match(ATAN2);
|
|
setState(409);
|
|
match(LPAREN);
|
|
setState(410);
|
|
expr();
|
|
setState(411);
|
|
match(COMMA);
|
|
setState(412);
|
|
expr();
|
|
setState(413);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new TMinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(415);
|
|
match(TMIN);
|
|
setState(416);
|
|
match(LPAREN);
|
|
setState(417);
|
|
expr();
|
|
setState(418);
|
|
match(COMMA);
|
|
setState(419);
|
|
expr();
|
|
setState(420);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new TMaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(422);
|
|
match(TMAX);
|
|
setState(423);
|
|
match(LPAREN);
|
|
setState(424);
|
|
expr();
|
|
setState(425);
|
|
match(COMMA);
|
|
setState(426);
|
|
expr();
|
|
setState(427);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new StepFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(429);
|
|
match(STEP);
|
|
setState(430);
|
|
match(LPAREN);
|
|
setState(431);
|
|
expr();
|
|
setState(432);
|
|
match(COMMA);
|
|
setState(433);
|
|
expr();
|
|
setState(434);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new TopkFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(436);
|
|
match(TOPK);
|
|
setState(437);
|
|
match(LPAREN);
|
|
setState(438);
|
|
expr();
|
|
setState(439);
|
|
match(COMMA);
|
|
setState(440);
|
|
expr();
|
|
setState(441);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new BotkFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(443);
|
|
match(BOTK);
|
|
setState(444);
|
|
match(LPAREN);
|
|
setState(445);
|
|
expr();
|
|
setState(446);
|
|
match(COMMA);
|
|
setState(447);
|
|
expr();
|
|
setState(448);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 8:
|
|
_localctx = new QuartileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(450);
|
|
match(QUARTILE);
|
|
setState(451);
|
|
match(LPAREN);
|
|
setState(452);
|
|
expr();
|
|
setState(453);
|
|
match(COMMA);
|
|
setState(454);
|
|
expr();
|
|
setState(455);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 9:
|
|
_localctx = new PercentileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(457);
|
|
match(PERCENTILE);
|
|
setState(458);
|
|
match(LPAREN);
|
|
setState(459);
|
|
expr();
|
|
setState(460);
|
|
match(COMMA);
|
|
setState(461);
|
|
expr();
|
|
setState(462);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 10:
|
|
_localctx = new QuantileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(464);
|
|
match(QUANTILE);
|
|
setState(465);
|
|
match(LPAREN);
|
|
setState(466);
|
|
expr();
|
|
setState(467);
|
|
match(COMMA);
|
|
setState(468);
|
|
expr();
|
|
setState(469);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 11:
|
|
_localctx = new QuantileFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(471);
|
|
match(QUANTILE);
|
|
setState(472);
|
|
match(LPAREN);
|
|
setState(473);
|
|
expr();
|
|
setState(474);
|
|
match(COMMA);
|
|
setState(475);
|
|
expr();
|
|
setState(476);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 12:
|
|
_localctx = new DotFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(478);
|
|
match(DOT);
|
|
setState(479);
|
|
match(LPAREN);
|
|
setState(480);
|
|
expr();
|
|
setState(481);
|
|
match(COMMA);
|
|
setState(482);
|
|
expr();
|
|
setState(483);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 13:
|
|
_localctx = new CossimFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(485);
|
|
match(COSSIM);
|
|
setState(486);
|
|
match(LPAREN);
|
|
setState(487);
|
|
expr();
|
|
setState(488);
|
|
match(COMMA);
|
|
setState(489);
|
|
expr();
|
|
setState(490);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 14:
|
|
_localctx = new FlipFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(492);
|
|
match(FLIP);
|
|
setState(493);
|
|
match(LPAREN);
|
|
setState(494);
|
|
expr();
|
|
setState(495);
|
|
match(COMMA);
|
|
setState(496);
|
|
expr();
|
|
setState(497);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 15:
|
|
_localctx = new CovFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(499);
|
|
match(COV);
|
|
setState(500);
|
|
match(LPAREN);
|
|
setState(501);
|
|
expr();
|
|
setState(502);
|
|
match(COMMA);
|
|
setState(503);
|
|
expr();
|
|
setState(504);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 16:
|
|
_localctx = new AppendFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(506);
|
|
match(APPEND);
|
|
setState(507);
|
|
match(LPAREN);
|
|
setState(508);
|
|
expr();
|
|
setState(509);
|
|
match(COMMA);
|
|
setState(510);
|
|
expr();
|
|
setState(511);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final Func3Context func3() throws RecognitionException {
|
|
Func3Context _localctx = new Func3Context(_ctx, getState());
|
|
enterRule(_localctx, 28, RULE_func3);
|
|
try {
|
|
setState(560);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case CLAMP:
|
|
_localctx = new ClampFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(515);
|
|
match(CLAMP);
|
|
setState(516);
|
|
match(LPAREN);
|
|
setState(517);
|
|
expr();
|
|
setState(518);
|
|
match(COMMA);
|
|
setState(519);
|
|
expr();
|
|
setState(520);
|
|
match(COMMA);
|
|
setState(521);
|
|
expr();
|
|
setState(522);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case LERP:
|
|
_localctx = new LerpFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(524);
|
|
match(LERP);
|
|
setState(525);
|
|
match(LPAREN);
|
|
setState(526);
|
|
expr();
|
|
setState(527);
|
|
match(COMMA);
|
|
setState(528);
|
|
expr();
|
|
setState(529);
|
|
match(COMMA);
|
|
setState(530);
|
|
expr();
|
|
setState(531);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SMOOTHSTEP:
|
|
_localctx = new SmoothstepFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(533);
|
|
match(SMOOTHSTEP);
|
|
setState(534);
|
|
match(LPAREN);
|
|
setState(535);
|
|
expr();
|
|
setState(536);
|
|
match(COMMA);
|
|
setState(537);
|
|
expr();
|
|
setState(538);
|
|
match(COMMA);
|
|
setState(539);
|
|
expr();
|
|
setState(540);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RANGE:
|
|
_localctx = new RangeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(542);
|
|
match(RANGE);
|
|
setState(543);
|
|
match(LPAREN);
|
|
setState(544);
|
|
expr();
|
|
setState(545);
|
|
match(COMMA);
|
|
setState(546);
|
|
expr();
|
|
setState(547);
|
|
match(COMMA);
|
|
setState(548);
|
|
expr();
|
|
setState(549);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MOMENT:
|
|
_localctx = new MomentFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(551);
|
|
match(MOMENT);
|
|
setState(552);
|
|
match(LPAREN);
|
|
setState(553);
|
|
expr();
|
|
setState(554);
|
|
match(COMMA);
|
|
setState(555);
|
|
expr();
|
|
setState(556);
|
|
match(COMMA);
|
|
setState(557);
|
|
expr();
|
|
setState(558);
|
|
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 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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final Func4Context func4() throws RecognitionException {
|
|
Func4Context _localctx = new Func4Context(_ctx, getState());
|
|
enterRule(_localctx, 30, RULE_func4);
|
|
try {
|
|
_localctx = new SwapFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(562);
|
|
match(SWAP);
|
|
setState(563);
|
|
match(LPAREN);
|
|
setState(564);
|
|
expr();
|
|
setState(565);
|
|
match(COMMA);
|
|
setState(566);
|
|
expr();
|
|
setState(567);
|
|
match(COMMA);
|
|
setState(568);
|
|
expr();
|
|
setState(569);
|
|
match(COMMA);
|
|
setState(570);
|
|
expr();
|
|
setState(571);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
public static class PermuteFuncContext extends FuncNContext {
|
|
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(FuncNContext ctx) { copyFrom(ctx); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
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); }
|
|
}
|
|
|
|
public final FuncNContext funcN() throws RecognitionException {
|
|
FuncNContext _localctx = new FuncNContext(_ctx, getState());
|
|
enterRule(_localctx, 32, RULE_funcN);
|
|
int _la;
|
|
try {
|
|
setState(644);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SMIN:
|
|
_localctx = new SMinFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(573);
|
|
match(SMIN);
|
|
setState(574);
|
|
match(LPAREN);
|
|
setState(575);
|
|
expr();
|
|
setState(580);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(576);
|
|
match(COMMA);
|
|
setState(577);
|
|
expr();
|
|
}
|
|
}
|
|
setState(582);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(583);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SMAX:
|
|
_localctx = new SMaxFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(585);
|
|
match(SMAX);
|
|
setState(586);
|
|
match(LPAREN);
|
|
setState(587);
|
|
expr();
|
|
setState(592);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(588);
|
|
match(COMMA);
|
|
setState(589);
|
|
expr();
|
|
}
|
|
}
|
|
setState(594);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(595);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case MAP:
|
|
_localctx = new MapFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(597);
|
|
match(MAP);
|
|
setState(598);
|
|
match(LPAREN);
|
|
setState(599);
|
|
expr();
|
|
setState(602);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(600);
|
|
match(COMMA);
|
|
setState(601);
|
|
expr();
|
|
}
|
|
}
|
|
setState(604);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(606);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case EZCONV:
|
|
_localctx = new EzConvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(608);
|
|
match(EZCONV);
|
|
setState(609);
|
|
match(LPAREN);
|
|
setState(610);
|
|
expr();
|
|
setState(613);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(611);
|
|
match(COMMA);
|
|
setState(612);
|
|
expr();
|
|
}
|
|
}
|
|
setState(615);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(617);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case CONV:
|
|
_localctx = new ConvFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(619);
|
|
match(CONV);
|
|
setState(620);
|
|
match(LPAREN);
|
|
setState(621);
|
|
expr();
|
|
setState(624);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(622);
|
|
match(COMMA);
|
|
setState(623);
|
|
expr();
|
|
}
|
|
}
|
|
setState(626);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==COMMA );
|
|
setState(628);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case PERM:
|
|
_localctx = new PermuteFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(630);
|
|
match(PERM);
|
|
setState(631);
|
|
match(LPAREN);
|
|
setState(632);
|
|
expr();
|
|
setState(633);
|
|
match(COMMA);
|
|
setState(634);
|
|
expr();
|
|
setState(635);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case RESHAPE:
|
|
_localctx = new ReshapeFuncContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(637);
|
|
match(RESHAPE);
|
|
setState(638);
|
|
match(LPAREN);
|
|
setState(639);
|
|
expr();
|
|
setState(640);
|
|
match(COMMA);
|
|
setState(641);
|
|
expr();
|
|
setState(642);
|
|
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 4:
|
|
return compExpr_sempred((CompExprContext)_localctx, predIndex);
|
|
case 5:
|
|
return addExpr_sempred((AddExprContext)_localctx, predIndex);
|
|
case 6:
|
|
return mulExpr_sempred((MulExprContext)_localctx, predIndex);
|
|
case 9:
|
|
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 indexExpr_sempred(IndexExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 11:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final String _serializedATN =
|
|
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3^\u0289\4\2\t\2\4"+
|
|
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
|
|
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
|
|
"\3\2\7\2&\n\2\f\2\16\2)\13\2\3\2\3\2\3\2\3\3\3\3\3\3\5\3\61\n\3\3\3\3"+
|
|
"\3\3\3\3\3\3\3\3\4\3\4\3\4\7\4;\n\4\f\4\16\4>\13\4\3\5\3\5\5\5B\n\5\3"+
|
|
"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6"+
|
|
"\3\6\3\6\3\6\7\6Y\n\6\f\6\16\6\\\13\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7"+
|
|
"\3\7\7\7g\n\7\f\7\16\7j\13\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
|
|
"\b\3\b\7\bx\n\b\f\b\16\b{\13\b\3\t\3\t\3\t\3\t\3\t\5\t\u0082\n\t\3\n\3"+
|
|
"\n\3\n\3\n\3\n\5\n\u0089\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7"+
|
|
"\13\u0093\n\13\f\13\16\13\u0096\13\13\3\13\3\13\7\13\u009a\n\13\f\13\16"+
|
|
"\13\u009d\13\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3"+
|
|
"\f\3\f\3\f\3\f\3\f\3\f\3\f\7\f\u00b3\n\f\f\f\16\f\u00b6\13\f\3\f\3\f\3"+
|
|
"\f\3\f\3\f\5\f\u00bd\n\f\3\f\5\f\u00c0\n\f\3\r\3\r\3\r\7\r\u00c5\n\r\f"+
|
|
"\r\16\r\u00c8\13\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3"+
|
|
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0192\n\16\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
|
|
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u0204\n\17"+
|
|
"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
|
|
"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
|
|
"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
|
|
"\3\20\3\20\3\20\5\20\u0233\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
|
|
"\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\7\22\u0245\n\22\f\22\16\22\u0248"+
|
|
"\13\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\7\22\u0251\n\22\f\22\16\22\u0254"+
|
|
"\13\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\6\22\u025d\n\22\r\22\16\22\u025e"+
|
|
"\3\22\3\22\3\22\3\22\3\22\3\22\3\22\6\22\u0268\n\22\r\22\16\22\u0269\3"+
|
|
"\22\3\22\3\22\3\22\3\22\3\22\3\22\6\22\u0273\n\22\r\22\16\22\u0274\3\22"+
|
|
"\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22"+
|
|
"\3\22\5\22\u0287\n\22\3\22\2\6\n\f\16\24\23\2\4\6\b\n\f\16\20\22\24\26"+
|
|
"\30\32\34\36 \"\2\2\2\u02de\2\'\3\2\2\2\4-\3\2\2\2\6\67\3\2\2\2\bA\3\2"+
|
|
"\2\2\nC\3\2\2\2\f]\3\2\2\2\16k\3\2\2\2\20\u0081\3\2\2\2\22\u0088\3\2\2"+
|
|
"\2\24\u008a\3\2\2\2\26\u00bf\3\2\2\2\30\u00c1\3\2\2\2\32\u0191\3\2\2\2"+
|
|
"\34\u0203\3\2\2\2\36\u0232\3\2\2\2 \u0234\3\2\2\2\"\u0286\3\2\2\2$&\5"+
|
|
"\4\3\2%$\3\2\2\2&)\3\2\2\2\'%\3\2\2\2\'(\3\2\2\2(*\3\2\2\2)\'\3\2\2\2"+
|
|
"*+\5\b\5\2+,\7\2\2\3,\3\3\2\2\2-.\7]\2\2.\60\7T\2\2/\61\5\6\4\2\60/\3"+
|
|
"\2\2\2\60\61\3\2\2\2\61\62\3\2\2\2\62\63\7U\2\2\63\64\7X\2\2\64\65\5\b"+
|
|
"\5\2\65\66\7W\2\2\66\5\3\2\2\2\67<\7]\2\289\7V\2\29;\7]\2\2:8\3\2\2\2"+
|
|
";>\3\2\2\2<:\3\2\2\2<=\3\2\2\2=\7\3\2\2\2><\3\2\2\2?B\5\26\f\2@B\5\n\6"+
|
|
"\2A?\3\2\2\2A@\3\2\2\2B\t\3\2\2\2CD\b\6\1\2DE\5\f\7\2EZ\3\2\2\2FG\f\t"+
|
|
"\2\2GH\7N\2\2HY\5\f\7\2IJ\f\b\2\2JK\7M\2\2KY\5\f\7\2LM\f\7\2\2MN\7P\2"+
|
|
"\2NY\5\f\7\2OP\f\6\2\2PQ\7O\2\2QY\5\f\7\2RS\f\5\2\2ST\7Q\2\2TY\5\f\7\2"+
|
|
"UV\f\4\2\2VW\7R\2\2WY\5\f\7\2XF\3\2\2\2XI\3\2\2\2XL\3\2\2\2XO\3\2\2\2"+
|
|
"XR\3\2\2\2XU\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[\13\3\2\2\2\\Z\3\2"+
|
|
"\2\2]^\b\7\1\2^_\5\16\b\2_h\3\2\2\2`a\f\5\2\2ab\7G\2\2bg\5\16\b\2cd\f"+
|
|
"\4\2\2de\7H\2\2eg\5\16\b\2f`\3\2\2\2fc\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3"+
|
|
"\2\2\2i\r\3\2\2\2jh\3\2\2\2kl\b\b\1\2lm\5\20\t\2my\3\2\2\2no\f\6\2\2o"+
|
|
"p\7I\2\2px\5\20\t\2qr\f\5\2\2rs\7J\2\2sx\5\20\t\2tu\f\4\2\2uv\7K\2\2v"+
|
|
"x\5\20\t\2wn\3\2\2\2wq\3\2\2\2wt\3\2\2\2x{\3\2\2\2yw\3\2\2\2yz\3\2\2\2"+
|
|
"z\17\3\2\2\2{y\3\2\2\2|}\5\22\n\2}~\7L\2\2~\177\5\20\t\2\177\u0082\3\2"+
|
|
"\2\2\u0080\u0082\5\22\n\2\u0081|\3\2\2\2\u0081\u0080\3\2\2\2\u0082\21"+
|
|
"\3\2\2\2\u0083\u0084\7G\2\2\u0084\u0089\5\22\n\2\u0085\u0086\7H\2\2\u0086"+
|
|
"\u0089\5\22\n\2\u0087\u0089\5\24\13\2\u0088\u0083\3\2\2\2\u0088\u0085"+
|
|
"\3\2\2\2\u0088\u0087\3\2\2\2\u0089\23\3\2\2\2\u008a\u008b\b\13\1\2\u008b"+
|
|
"\u008c\5\26\f\2\u008c\u009b\3\2\2\2\u008d\u008e\f\4\2\2\u008e\u008f\7"+
|
|
"Y\2\2\u008f\u0094\5\b\5\2\u0090\u0091\7V\2\2\u0091\u0093\5\b\5\2\u0092"+
|
|
"\u0090\3\2\2\2\u0093\u0096\3\2\2\2\u0094\u0092\3\2\2\2\u0094\u0095\3\2"+
|
|
"\2\2\u0095\u0097\3\2\2\2\u0096\u0094\3\2\2\2\u0097\u0098\7Z\2\2\u0098"+
|
|
"\u009a\3\2\2\2\u0099\u008d\3\2\2\2\u009a\u009d\3\2\2\2\u009b\u0099\3\2"+
|
|
"\2\2\u009b\u009c\3\2\2\2\u009c\25\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u00c0"+
|
|
"\5\32\16\2\u009f\u00c0\5\34\17\2\u00a0\u00c0\5\36\20\2\u00a1\u00c0\5 "+
|
|
"\21\2\u00a2\u00c0\5\"\22\2\u00a3\u00c0\7]\2\2\u00a4\u00c0\7\\\2\2\u00a5"+
|
|
"\u00c0\7[\2\2\u00a6\u00a7\7T\2\2\u00a7\u00a8\5\b\5\2\u00a8\u00a9\7U\2"+
|
|
"\2\u00a9\u00c0\3\2\2\2\u00aa\u00ab\7S\2\2\u00ab\u00ac\5\b\5\2\u00ac\u00ad"+
|
|
"\7S\2\2\u00ad\u00c0\3\2\2\2\u00ae\u00af\7Y\2\2\u00af\u00b4\5\b\5\2\u00b0"+
|
|
"\u00b1\7V\2\2\u00b1\u00b3\5\b\5\2\u00b2\u00b0\3\2\2\2\u00b3\u00b6\3\2"+
|
|
"\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7\3\2\2\2\u00b6"+
|
|
"\u00b4\3\2\2\2\u00b7\u00b8\7Z\2\2\u00b8\u00c0\3\2\2\2\u00b9\u00ba\7]\2"+
|
|
"\2\u00ba\u00bc\7T\2\2\u00bb\u00bd\5\30\r\2\u00bc\u00bb\3\2\2\2\u00bc\u00bd"+
|
|
"\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00c0\7U\2\2\u00bf\u009e\3\2\2\2\u00bf"+
|
|
"\u009f\3\2\2\2\u00bf\u00a0\3\2\2\2\u00bf\u00a1\3\2\2\2\u00bf\u00a2\3\2"+
|
|
"\2\2\u00bf\u00a3\3\2\2\2\u00bf\u00a4\3\2\2\2\u00bf\u00a5\3\2\2\2\u00bf"+
|
|
"\u00a6\3\2\2\2\u00bf\u00aa\3\2\2\2\u00bf\u00ae\3\2\2\2\u00bf\u00b9\3\2"+
|
|
"\2\2\u00c0\27\3\2\2\2\u00c1\u00c6\5\b\5\2\u00c2\u00c3\7V\2\2\u00c3\u00c5"+
|
|
"\5\b\5\2\u00c4\u00c2\3\2\2\2\u00c5\u00c8\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6"+
|
|
"\u00c7\3\2\2\2\u00c7\31\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c9\u00ca\7\3\2"+
|
|
"\2\u00ca\u00cb\7T\2\2\u00cb\u00cc\5\b\5\2\u00cc\u00cd\7U\2\2\u00cd\u0192"+
|
|
"\3\2\2\2\u00ce\u00cf\7\4\2\2\u00cf\u00d0\7T\2\2\u00d0\u00d1\5\b\5\2\u00d1"+
|
|
"\u00d2\7U\2\2\u00d2\u0192\3\2\2\2\u00d3\u00d4\7\5\2\2\u00d4\u00d5\7T\2"+
|
|
"\2\u00d5\u00d6\5\b\5\2\u00d6\u00d7\7U\2\2\u00d7\u0192\3\2\2\2\u00d8\u00d9"+
|
|
"\7\6\2\2\u00d9\u00da\7T\2\2\u00da\u00db\5\b\5\2\u00db\u00dc\7U\2\2\u00dc"+
|
|
"\u0192\3\2\2\2\u00dd\u00de\7\7\2\2\u00de\u00df\7T\2\2\u00df\u00e0\5\b"+
|
|
"\5\2\u00e0\u00e1\7U\2\2\u00e1\u0192\3\2\2\2\u00e2\u00e3\7\b\2\2\u00e3"+
|
|
"\u00e4\7T\2\2\u00e4\u00e5\5\b\5\2\u00e5\u00e6\7U\2\2\u00e6\u0192\3\2\2"+
|
|
"\2\u00e7\u00e8\7\n\2\2\u00e8\u00e9\7T\2\2\u00e9\u00ea\5\b\5\2\u00ea\u00eb"+
|
|
"\7U\2\2\u00eb\u0192\3\2\2\2\u00ec\u00ed\7\13\2\2\u00ed\u00ee\7T\2\2\u00ee"+
|
|
"\u00ef\5\b\5\2\u00ef\u00f0\7U\2\2\u00f0\u0192\3\2\2\2\u00f1\u00f2\7\f"+
|
|
"\2\2\u00f2\u00f3\7T\2\2\u00f3\u00f4\5\b\5\2\u00f4\u00f5\7U\2\2\u00f5\u0192"+
|
|
"\3\2\2\2\u00f6\u00f7\7\r\2\2\u00f7\u00f8\7T\2\2\u00f8\u00f9\5\b\5\2\u00f9"+
|
|
"\u00fa\7U\2\2\u00fa\u0192\3\2\2\2\u00fb\u00fc\7\16\2\2\u00fc\u00fd\7T"+
|
|
"\2\2\u00fd\u00fe\5\b\5\2\u00fe\u00ff\7U\2\2\u00ff\u0192\3\2\2\2\u0100"+
|
|
"\u0101\7\17\2\2\u0101\u0102\7T\2\2\u0102\u0103\5\b\5\2\u0103\u0104\7U"+
|
|
"\2\2\u0104\u0192\3\2\2\2\u0105\u0106\7\20\2\2\u0106\u0107\7T\2\2\u0107"+
|
|
"\u0108\5\b\5\2\u0108\u0109\7U\2\2\u0109\u0192\3\2\2\2\u010a\u010b\7\21"+
|
|
"\2\2\u010b\u010c\7T\2\2\u010c\u010d\5\b\5\2\u010d\u010e\7U\2\2\u010e\u0192"+
|
|
"\3\2\2\2\u010f\u0110\7\22\2\2\u0110\u0111\7T\2\2\u0111\u0112\5\b\5\2\u0112"+
|
|
"\u0113\7U\2\2\u0113\u0192\3\2\2\2\u0114\u0115\7\23\2\2\u0115\u0116\7T"+
|
|
"\2\2\u0116\u0117\5\b\5\2\u0117\u0118\7U\2\2\u0118\u0192\3\2\2\2\u0119"+
|
|
"\u011a\7\24\2\2\u011a\u011b\7T\2\2\u011b\u011c\5\b\5\2\u011c\u011d\7U"+
|
|
"\2\2\u011d\u0192\3\2\2\2\u011e\u011f\7\31\2\2\u011f\u0120\7T\2\2\u0120"+
|
|
"\u0121\5\b\5\2\u0121\u0122\7U\2\2\u0122\u0192\3\2\2\2\u0123\u0124\7\32"+
|
|
"\2\2\u0124\u0125\7T\2\2\u0125\u0126\5\b\5\2\u0126\u0127\7U\2\2\u0127\u0192"+
|
|
"\3\2\2\2\u0128\u0129\7\33\2\2\u0129\u012a\7T\2\2\u012a\u012b\5\b\5\2\u012b"+
|
|
"\u012c\7U\2\2\u012c\u0192\3\2\2\2\u012d\u012e\7\34\2\2\u012e\u012f\7T"+
|
|
"\2\2\u012f\u0130\5\b\5\2\u0130\u0131\7U\2\2\u0131\u0192\3\2\2\2\u0132"+
|
|
"\u0133\7\35\2\2\u0133\u0134\7T\2\2\u0134\u0135\5\b\5\2\u0135\u0136\7U"+
|
|
"\2\2\u0136\u0192\3\2\2\2\u0137\u0138\7\36\2\2\u0138\u0139\7T\2\2\u0139"+
|
|
"\u013a\5\b\5\2\u013a\u013b\7U\2\2\u013b\u0192\3\2\2\2\u013c\u013d\7 \2"+
|
|
"\2\u013d\u013e\7T\2\2\u013e\u013f\5\b\5\2\u013f\u0140\7U\2\2\u0140\u0192"+
|
|
"\3\2\2\2\u0141\u0142\7\"\2\2\u0142\u0143\7T\2\2\u0143\u0144\5\b\5\2\u0144"+
|
|
"\u0145\7U\2\2\u0145\u0192\3\2\2\2\u0146\u0147\7#\2\2\u0147\u0148\7T\2"+
|
|
"\2\u0148\u0149\5\b\5\2\u0149\u014a\7U\2\2\u014a\u0192\3\2\2\2\u014b\u014c"+
|
|
"\7$\2\2\u014c\u014d\7T\2\2\u014d\u014e\5\b\5\2\u014e\u014f\7U\2\2\u014f"+
|
|
"\u0192\3\2\2\2\u0150\u0151\7%\2\2\u0151\u0152\7T\2\2\u0152\u0153\5\b\5"+
|
|
"\2\u0153\u0154\7U\2\2\u0154\u0192\3\2\2\2\u0155\u0156\7*\2\2\u0156\u0157"+
|
|
"\7T\2\2\u0157\u0158\5\b\5\2\u0158\u0159\7U\2\2\u0159\u0192\3\2\2\2\u015a"+
|
|
"\u015b\7+\2\2\u015b\u015c\7T\2\2\u015c\u015d\5\b\5\2\u015d\u015e\7U\2"+
|
|
"\2\u015e\u0192\3\2\2\2\u015f\u0160\7,\2\2\u0160\u0161\7T\2\2\u0161\u0162"+
|
|
"\5\b\5\2\u0162\u0163\7U\2\2\u0163\u0192\3\2\2\2\u0164\u0165\7-\2\2\u0165"+
|
|
"\u0166\7T\2\2\u0166\u0167\5\b\5\2\u0167\u0168\7U\2\2\u0168\u0192\3\2\2"+
|
|
"\2\u0169\u016a\7.\2\2\u016a\u016b\7T\2\2\u016b\u016c\5\b\5\2\u016c\u016d"+
|
|
"\7U\2\2\u016d\u0192\3\2\2\2\u016e\u016f\7&\2\2\u016f\u0170\7T\2\2\u0170"+
|
|
"\u0171\5\b\5\2\u0171\u0172\7U\2\2\u0172\u0192\3\2\2\2\u0173\u0174\78\2"+
|
|
"\2\u0174\u0175\7T\2\2\u0175\u0176\5\b\5\2\u0176\u0177\7U\2\2\u0177\u0192"+
|
|
"\3\2\2\2\u0178\u0179\79\2\2\u0179\u017a\7T\2\2\u017a\u017b\5\b\5\2\u017b"+
|
|
"\u017c\7U\2\2\u017c\u0192\3\2\2\2\u017d\u017e\7:\2\2\u017e\u017f\7T\2"+
|
|
"\2\u017f\u0180\5\b\5\2\u0180\u0181\7U\2\2\u0181\u0192\3\2\2\2\u0182\u0183"+
|
|
"\7;\2\2\u0183\u0184\7T\2\2\u0184\u0185\5\b\5\2\u0185\u0186\7U\2\2\u0186"+
|
|
"\u0192\3\2\2\2\u0187\u0188\7<\2\2\u0188\u0189\7T\2\2\u0189\u018a\5\b\5"+
|
|
"\2\u018a\u018b\7U\2\2\u018b\u0192\3\2\2\2\u018c\u018d\7E\2\2\u018d\u018e"+
|
|
"\7T\2\2\u018e\u018f\5\b\5\2\u018f\u0190\7U\2\2\u0190\u0192\3\2\2\2\u0191"+
|
|
"\u00c9\3\2\2\2\u0191\u00ce\3\2\2\2\u0191\u00d3\3\2\2\2\u0191\u00d8\3\2"+
|
|
"\2\2\u0191\u00dd\3\2\2\2\u0191\u00e2\3\2\2\2\u0191\u00e7\3\2\2\2\u0191"+
|
|
"\u00ec\3\2\2\2\u0191\u00f1\3\2\2\2\u0191\u00f6\3\2\2\2\u0191\u00fb\3\2"+
|
|
"\2\2\u0191\u0100\3\2\2\2\u0191\u0105\3\2\2\2\u0191\u010a\3\2\2\2\u0191"+
|
|
"\u010f\3\2\2\2\u0191\u0114\3\2\2\2\u0191\u0119\3\2\2\2\u0191\u011e\3\2"+
|
|
"\2\2\u0191\u0123\3\2\2\2\u0191\u0128\3\2\2\2\u0191\u012d\3\2\2\2\u0191"+
|
|
"\u0132\3\2\2\2\u0191\u0137\3\2\2\2\u0191\u013c\3\2\2\2\u0191\u0141\3\2"+
|
|
"\2\2\u0191\u0146\3\2\2\2\u0191\u014b\3\2\2\2\u0191\u0150\3\2\2\2\u0191"+
|
|
"\u0155\3\2\2\2\u0191\u015a\3\2\2\2\u0191\u015f\3\2\2\2\u0191\u0164\3\2"+
|
|
"\2\2\u0191\u0169\3\2\2\2\u0191\u016e\3\2\2\2\u0191\u0173\3\2\2\2\u0191"+
|
|
"\u0178\3\2\2\2\u0191\u017d\3\2\2\2\u0191\u0182\3\2\2\2\u0191\u0187\3\2"+
|
|
"\2\2\u0191\u018c\3\2\2\2\u0192\33\3\2\2\2\u0193\u0194\7\37\2\2\u0194\u0195"+
|
|
"\7T\2\2\u0195\u0196\5\b\5\2\u0196\u0197\7V\2\2\u0197\u0198\5\b\5\2\u0198"+
|
|
"\u0199\7U\2\2\u0199\u0204\3\2\2\2\u019a\u019b\7\t\2\2\u019b\u019c\7T\2"+
|
|
"\2\u019c\u019d\5\b\5\2\u019d\u019e\7V\2\2\u019e\u019f\5\b\5\2\u019f\u01a0"+
|
|
"\7U\2\2\u01a0\u0204\3\2\2\2\u01a1\u01a2\7\27\2\2\u01a2\u01a3\7T\2\2\u01a3"+
|
|
"\u01a4\5\b\5\2\u01a4\u01a5\7V\2\2\u01a5\u01a6\5\b\5\2\u01a6\u01a7\7U\2"+
|
|
"\2\u01a7\u0204\3\2\2\2\u01a8\u01a9\7\30\2\2\u01a9\u01aa\7T\2\2\u01aa\u01ab"+
|
|
"\5\b\5\2\u01ab\u01ac\7V\2\2\u01ac\u01ad\5\b\5\2\u01ad\u01ae\7U\2\2\u01ae"+
|
|
"\u0204\3\2\2\2\u01af\u01b0\7(\2\2\u01b0\u01b1\7T\2\2\u01b1\u01b2\5\b\5"+
|
|
"\2\u01b2\u01b3\7V\2\2\u01b3\u01b4\5\b\5\2\u01b4\u01b5\7U\2\2\u01b5\u0204"+
|
|
"\3\2\2\2\u01b6\u01b7\7\66\2\2\u01b7\u01b8\7T\2\2\u01b8\u01b9\5\b\5\2\u01b9"+
|
|
"\u01ba\7V\2\2\u01ba\u01bb\5\b\5\2\u01bb\u01bc\7U\2\2\u01bc\u0204\3\2\2"+
|
|
"\2\u01bd\u01be\7\67\2\2\u01be\u01bf\7T\2\2\u01bf\u01c0\5\b\5\2\u01c0\u01c1"+
|
|
"\7V\2\2\u01c1\u01c2\5\b\5\2\u01c2\u01c3\7U\2\2\u01c3\u0204\3\2\2\2\u01c4"+
|
|
"\u01c5\7=\2\2\u01c5\u01c6\7T\2\2\u01c6\u01c7\5\b\5\2\u01c7\u01c8\7V\2"+
|
|
"\2\u01c8\u01c9\5\b\5\2\u01c9\u01ca\7U\2\2\u01ca\u0204\3\2\2\2\u01cb\u01cc"+
|
|
"\7>\2\2\u01cc\u01cd\7T\2\2\u01cd\u01ce\5\b\5\2\u01ce\u01cf\7V\2\2\u01cf"+
|
|
"\u01d0\5\b\5\2\u01d0\u01d1\7U\2\2\u01d1\u0204\3\2\2\2\u01d2\u01d3\7?\2"+
|
|
"\2\u01d3\u01d4\7T\2\2\u01d4\u01d5\5\b\5\2\u01d5\u01d6\7V\2\2\u01d6\u01d7"+
|
|
"\5\b\5\2\u01d7\u01d8\7U\2\2\u01d8\u0204\3\2\2\2\u01d9\u01da\7?\2\2\u01da"+
|
|
"\u01db\7T\2\2\u01db\u01dc\5\b\5\2\u01dc\u01dd\7V\2\2\u01dd\u01de\5\b\5"+
|
|
"\2\u01de\u01df\7U\2\2\u01df\u0204\3\2\2\2\u01e0\u01e1\7@\2\2\u01e1\u01e2"+
|
|
"\7T\2\2\u01e2\u01e3\5\b\5\2\u01e3\u01e4\7V\2\2\u01e4\u01e5\5\b\5\2\u01e5"+
|
|
"\u01e6\7U\2\2\u01e6\u0204\3\2\2\2\u01e7\u01e8\7B\2\2\u01e8\u01e9\7T\2"+
|
|
"\2\u01e9\u01ea\5\b\5\2\u01ea\u01eb\7V\2\2\u01eb\u01ec\5\b\5\2\u01ec\u01ed"+
|
|
"\7U\2\2\u01ed\u0204\3\2\2\2\u01ee\u01ef\7C\2\2\u01ef\u01f0\7T\2\2\u01f0"+
|
|
"\u01f1\5\b\5\2\u01f1\u01f2\7V\2\2\u01f2\u01f3\5\b\5\2\u01f3\u01f4\7U\2"+
|
|
"\2\u01f4\u0204\3\2\2\2\u01f5\u01f6\7D\2\2\u01f6\u01f7\7T\2\2\u01f7\u01f8"+
|
|
"\5\b\5\2\u01f8\u01f9\7V\2\2\u01f9\u01fa\5\b\5\2\u01fa\u01fb\7U\2\2\u01fb"+
|
|
"\u0204\3\2\2\2\u01fc\u01fd\7F\2\2\u01fd\u01fe\7T\2\2\u01fe\u01ff\5\b\5"+
|
|
"\2\u01ff\u0200\7V\2\2\u0200\u0201\5\b\5\2\u0201\u0202\7U\2\2\u0202\u0204"+
|
|
"\3\2\2\2\u0203\u0193\3\2\2\2\u0203\u019a\3\2\2\2\u0203\u01a1\3\2\2\2\u0203"+
|
|
"\u01a8\3\2\2\2\u0203\u01af\3\2\2\2\u0203\u01b6\3\2\2\2\u0203\u01bd\3\2"+
|
|
"\2\2\u0203\u01c4\3\2\2\2\u0203\u01cb\3\2\2\2\u0203\u01d2\3\2\2\2\u0203"+
|
|
"\u01d9\3\2\2\2\u0203\u01e0\3\2\2\2\u0203\u01e7\3\2\2\2\u0203\u01ee\3\2"+
|
|
"\2\2\u0203\u01f5\3\2\2\2\u0203\u01fc\3\2\2\2\u0204\35\3\2\2\2\u0205\u0206"+
|
|
"\7!\2\2\u0206\u0207\7T\2\2\u0207\u0208\5\b\5\2\u0208\u0209\7V\2\2\u0209"+
|
|
"\u020a\5\b\5\2\u020a\u020b\7V\2\2\u020b\u020c\5\b\5\2\u020c\u020d\7U\2"+
|
|
"\2\u020d\u0233\3\2\2\2\u020e\u020f\7\'\2\2\u020f\u0210\7T\2\2\u0210\u0211"+
|
|
"\5\b\5\2\u0211\u0212\7V\2\2\u0212\u0213\5\b\5\2\u0213\u0214\7V\2\2\u0214"+
|
|
"\u0215\5\b\5\2\u0215\u0216\7U\2\2\u0216\u0233\3\2\2\2\u0217\u0218\7)\2"+
|
|
"\2\u0218\u0219\7T\2\2\u0219\u021a\5\b\5\2\u021a\u021b\7V\2\2\u021b\u021c"+
|
|
"\5\b\5\2\u021c\u021d\7V\2\2\u021d\u021e\5\b\5\2\u021e\u021f\7U\2\2\u021f"+
|
|
"\u0233\3\2\2\2\u0220\u0221\7\65\2\2\u0221\u0222\7T\2\2\u0222\u0223\5\b"+
|
|
"\5\2\u0223\u0224\7V\2\2\u0224\u0225\5\b\5\2\u0225\u0226\7V\2\2\u0226\u0227"+
|
|
"\5\b\5\2\u0227\u0228\7U\2\2\u0228\u0233\3\2\2\2\u0229\u022a\7A\2\2\u022a"+
|
|
"\u022b\7T\2\2\u022b\u022c\5\b\5\2\u022c\u022d\7V\2\2\u022d\u022e\5\b\5"+
|
|
"\2\u022e\u022f\7V\2\2\u022f\u0230\5\b\5\2\u0230\u0231\7U\2\2\u0231\u0233"+
|
|
"\3\2\2\2\u0232\u0205\3\2\2\2\u0232\u020e\3\2\2\2\u0232\u0217\3\2\2\2\u0232"+
|
|
"\u0220\3\2\2\2\u0232\u0229\3\2\2\2\u0233\37\3\2\2\2\u0234\u0235\7\62\2"+
|
|
"\2\u0235\u0236\7T\2\2\u0236\u0237\5\b\5\2\u0237\u0238\7V\2\2\u0238\u0239"+
|
|
"\5\b\5\2\u0239\u023a\7V\2\2\u023a\u023b\5\b\5\2\u023b\u023c\7V\2\2\u023c"+
|
|
"\u023d\5\b\5\2\u023d\u023e\7U\2\2\u023e!\3\2\2\2\u023f\u0240\7\25\2\2"+
|
|
"\u0240\u0241\7T\2\2\u0241\u0246\5\b\5\2\u0242\u0243\7V\2\2\u0243\u0245"+
|
|
"\5\b\5\2\u0244\u0242\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2\u0246"+
|
|
"\u0247\3\2\2\2\u0247\u0249\3\2\2\2\u0248\u0246\3\2\2\2\u0249\u024a\7U"+
|
|
"\2\2\u024a\u0287\3\2\2\2\u024b\u024c\7\26\2\2\u024c\u024d\7T\2\2\u024d"+
|
|
"\u0252\5\b\5\2\u024e\u024f\7V\2\2\u024f\u0251\5\b\5\2\u0250\u024e\3\2"+
|
|
"\2\2\u0251\u0254\3\2\2\2\u0252\u0250\3\2\2\2\u0252\u0253\3\2\2\2\u0253"+
|
|
"\u0255\3\2\2\2\u0254\u0252\3\2\2\2\u0255\u0256\7U\2\2\u0256\u0287\3\2"+
|
|
"\2\2\u0257\u0258\7/\2\2\u0258\u0259\7T\2\2\u0259\u025c\5\b\5\2\u025a\u025b"+
|
|
"\7V\2\2\u025b\u025d\5\b\5\2\u025c\u025a\3\2\2\2\u025d\u025e\3\2\2\2\u025e"+
|
|
"\u025c\3\2\2\2\u025e\u025f\3\2\2\2\u025f\u0260\3\2\2\2\u0260\u0261\7U"+
|
|
"\2\2\u0261\u0287\3\2\2\2\u0262\u0263\7\60\2\2\u0263\u0264\7T\2\2\u0264"+
|
|
"\u0267\5\b\5\2\u0265\u0266\7V\2\2\u0266\u0268\5\b\5\2\u0267\u0265\3\2"+
|
|
"\2\2\u0268\u0269\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a"+
|
|
"\u026b\3\2\2\2\u026b\u026c\7U\2\2\u026c\u0287\3\2\2\2\u026d\u026e\7\61"+
|
|
"\2\2\u026e\u026f\7T\2\2\u026f\u0272\5\b\5\2\u0270\u0271\7V\2\2\u0271\u0273"+
|
|
"\5\b\5\2\u0272\u0270\3\2\2\2\u0273\u0274\3\2\2\2\u0274\u0272\3\2\2\2\u0274"+
|
|
"\u0275\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0277\7U\2\2\u0277\u0287\3\2"+
|
|
"\2\2\u0278\u0279\7\63\2\2\u0279\u027a\7T\2\2\u027a\u027b\5\b\5\2\u027b"+
|
|
"\u027c\7V\2\2\u027c\u027d\5\b\5\2\u027d\u027e\7U\2\2\u027e\u0287\3\2\2"+
|
|
"\2\u027f\u0280\7\64\2\2\u0280\u0281\7T\2\2\u0281\u0282\5\b\5\2\u0282\u0283"+
|
|
"\7V\2\2\u0283\u0284\5\b\5\2\u0284\u0285\7U\2\2\u0285\u0287\3\2\2\2\u0286"+
|
|
"\u023f\3\2\2\2\u0286\u024b\3\2\2\2\u0286\u0257\3\2\2\2\u0286\u0262\3\2"+
|
|
"\2\2\u0286\u026d\3\2\2\2\u0286\u0278\3\2\2\2\u0286\u027f\3\2\2\2\u0287"+
|
|
"#\3\2\2\2\35\'\60<AXZfhwy\u0081\u0088\u0094\u009b\u00b4\u00bc\u00bf\u00c6"+
|
|
"\u0191\u0203\u0232\u0246\u0252\u025e\u0269\u0274\u0286";
|
|
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);
|
|
}
|
|
}
|
|
} |