diff --git a/more_math/Parser/MathExpr.g4 b/more_math/Parser/MathExpr.g4
index ed0f548..5dd71f8 100644
--- a/more_math/Parser/MathExpr.g4
+++ b/more_math/Parser/MathExpr.g4
@@ -23,9 +23,9 @@ stmt:
 ifStmt: IF LPAREN expr RPAREN stmt (ELSE stmt)?;
 whileStmt: WHILE LPAREN expr RPAREN stmt;
 block: LBRACE stmt* RBRACE;
-breakStmt: BRK SEMICOLON;
-continueStmt: CONT SEMICOLON;
-returnStmt: RET expr? SEMICOLON;
+breakStmt: BREAK SEMICOLON;
+continueStmt: CONTINUE SEMICOLON;
+returnStmt: RETURN expr? SEMICOLON;
 
 expr: ternaryExpr | atom | compExpr;
 
@@ -281,7 +281,7 @@ REMAP: 'remap';
 IF: 'if';
 ELSE: 'else';
 WHILE: 'while';
-RET: 'return';
+RETURN: 'return';
 PUSH: 'push';
 POP: 'pop';
 CLEAR: 'clear';
@@ -303,8 +303,8 @@ SORT: 'sort';
 APPEND: 'append';
 
 TIMESTAMP: 'timestamp' | 'now';
-BRK: 'break';
-CONT: 'continue';
+BREAK: 'break';
+CONTINUE: 'continue';
 
 PLUS: '+';
 MINUS: '-';
@@ -339,4 +339,4 @@ VARIABLE: [a-zA-Z_] [a-zA-Z_0-9]*;
 
 SL_COMMENT : '#' ~[\r\n]* -> skip;
 ML_COMMENT : '/*' .*? '*/' -> skip;
-WS: [ \t\r\n]+ -> skip;
+WS: [ \t\r\n]+ -> skip;
\ No newline at end of file
diff --git a/more_math/Parser/MathExpr.interp b/more_math/Parser/MathExpr.interp
index 3d4fc37..1c9737a 100644
--- a/more_math/Parser/MathExpr.interp
+++ b/more_math/Parser/MathExpr.interp
@@ -221,7 +221,7 @@ REMAP
 IF
 ELSE
 WHILE
-RET
+RETURN
 PUSH
 POP
 CLEAR
@@ -240,8 +240,8 @@ COV
 SORT
 APPEND
 TIMESTAMP
-BRK
-CONT
+BREAK
+CONTINUE
 PLUS
 MINUS
 MULT
diff --git a/more_math/Parser/MathExpr.tokens b/more_math/Parser/MathExpr.tokens
index 459710d..d37702a 100644
--- a/more_math/Parser/MathExpr.tokens
+++ b/more_math/Parser/MathExpr.tokens
@@ -81,7 +81,7 @@ REMAP=80
 IF=81
 ELSE=82
 WHILE=83
-RET=84
+RETURN=84
 PUSH=85
 POP=86
 CLEAR=87
@@ -100,8 +100,8 @@ COV=99
 SORT=100
 APPEND=101
 TIMESTAMP=102
-BRK=103
-CONT=104
+BREAK=103
+CONTINUE=104
 PLUS=105
 MINUS=106
 MULT=107
diff --git a/more_math/Parser/MathExprLexer.interp b/more_math/Parser/MathExprLexer.interp
index 8966e74..d3f2109 100644
--- a/more_math/Parser/MathExprLexer.interp
+++ b/more_math/Parser/MathExprLexer.interp
@@ -221,7 +221,7 @@ REMAP
 IF
 ELSE
 WHILE
-RET
+RETURN
 PUSH
 POP
 CLEAR
@@ -240,8 +240,8 @@ COV
 SORT
 APPEND
 TIMESTAMP
-BRK
-CONT
+BREAK
+CONTINUE
 PLUS
 MINUS
 MULT
@@ -358,7 +358,7 @@ REMAP
 IF
 ELSE
 WHILE
-RET
+RETURN
 PUSH
 POP
 CLEAR
@@ -377,8 +377,8 @@ COV
 SORT
 APPEND
 TIMESTAMP
-BRK
-CONT
+BREAK
+CONTINUE
 PLUS
 MINUS
 MULT
diff --git a/more_math/Parser/MathExprLexer.py b/more_math/Parser/MathExprLexer.py
index 9a67eaa..90b172e 100644
--- a/more_math/Parser/MathExprLexer.py
+++ b/more_math/Parser/MathExprLexer.py
@@ -562,7 +562,7 @@ class MathExprLexer(Lexer):
     IF = 81
     ELSE = 82
     WHILE = 83
-    RET = 84
+    RETURN = 84
     PUSH = 85
     POP = 86
     CLEAR = 87
@@ -581,8 +581,8 @@ class MathExprLexer(Lexer):
     SORT = 100
     APPEND = 101
     TIMESTAMP = 102
-    BRK = 103
-    CONT = 104
+    BREAK = 103
+    CONTINUE = 104
     PLUS = 105
     MINUS = 106
     MULT = 107
@@ -650,15 +650,15 @@ class MathExprLexer(Lexer):
             "PERCENTILE", "QUANTILE", "DOT", "MOMENT", "ANY", "ALL", "EDGE", 
             "GAUSSIAN", "MEDIAN", "MODE", "CUMSUM", "CUMPROD", "TOPK_IND", 
             "BOTK_IND", "CUBIC_EASE", "ELASTIC_EASE", "SINE_EASE", "SMOOTHERSTEP", 
-            "DIST", "REMAP", "IF", "ELSE", "WHILE", "RET", "PUSH", "POP", 
+            "DIST", "REMAP", "IF", "ELSE", "WHILE", "RETURN", "PUSH", "POP", 
             "CLEAR", "HAS", "GET", "NOISE", "RAND", "CAUCHY", "EXPONENTIAL", 
             "LOGNORMAL", "BERNOULLI", "POISSON", "COSSIM", "FLIP", "COV", 
-            "SORT", "APPEND", "TIMESTAMP", "BRK", "CONT", "PLUS", "MINUS", 
-            "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", "EQ", "EQUEALS", 
-            "NE", "PIPE", "LPAREN", "RPAREN", "COMMA", "SEMICOLON", "ARROW", 
-            "LBRACKET", "RBRACKET", "QUESTION", "COLON", "LBRACE", "RBRACE", 
-            "CONSTANT", "NUMBER", "VARIABLE", "SL_COMMENT", "ML_COMMENT", 
-            "WS" ]
+            "SORT", "APPEND", "TIMESTAMP", "BREAK", "CONTINUE", "PLUS", 
+            "MINUS", "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", 
+            "EQ", "EQUEALS", "NE", "PIPE", "LPAREN", "RPAREN", "COMMA", 
+            "SEMICOLON", "ARROW", "LBRACKET", "RBRACKET", "QUESTION", "COLON", 
+            "LBRACE", "RBRACE", "CONSTANT", "NUMBER", "VARIABLE", "SL_COMMENT", 
+            "ML_COMMENT", "WS" ]
 
     ruleNames = [ "SIN", "COS", "TAN", "ASIN", "ACOS", "ATAN", "ATAN2", 
                   "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "ABS", 
@@ -672,12 +672,12 @@ class MathExprLexer(Lexer):
                   "DOT", "MOMENT", "ANY", "ALL", "EDGE", "GAUSSIAN", "MEDIAN", 
                   "MODE", "CUMSUM", "CUMPROD", "TOPK_IND", "BOTK_IND", "CUBIC_EASE", 
                   "ELASTIC_EASE", "SINE_EASE", "SMOOTHERSTEP", "DIST", "REMAP", 
-                  "IF", "ELSE", "WHILE", "RET", "PUSH", "POP", "CLEAR", 
+                  "IF", "ELSE", "WHILE", "RETURN", "PUSH", "POP", "CLEAR", 
                   "HAS", "GET", "NOISE", "RAND", "CAUCHY", "EXPONENTIAL", 
                   "LOGNORMAL", "BERNOULLI", "POISSON", "COSSIM", "FLIP", 
-                  "COV", "SORT", "APPEND", "TIMESTAMP", "BRK", "CONT", "PLUS", 
-                  "MINUS", "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", 
-                  "LT", "EQ", "EQUEALS", "NE", "PIPE", "LPAREN", "RPAREN", 
+                  "COV", "SORT", "APPEND", "TIMESTAMP", "BREAK", "CONTINUE", 
+                  "PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", "GE", "GT", 
+                  "LE", "LT", "EQ", "EQUEALS", "NE", "PIPE", "LPAREN", "RPAREN", 
                   "COMMA", "SEMICOLON", "ARROW", "LBRACKET", "RBRACKET", 
                   "QUESTION", "COLON", "LBRACE", "RBRACE", "CONSTANT", "NUMBER", 
                   "VARIABLE", "SL_COMMENT", "ML_COMMENT", "WS" ]
diff --git a/more_math/Parser/MathExprLexer.tokens b/more_math/Parser/MathExprLexer.tokens
index 459710d..d37702a 100644
--- a/more_math/Parser/MathExprLexer.tokens
+++ b/more_math/Parser/MathExprLexer.tokens
@@ -81,7 +81,7 @@ REMAP=80
 IF=81
 ELSE=82
 WHILE=83
-RET=84
+RETURN=84
 PUSH=85
 POP=86
 CLEAR=87
@@ -100,8 +100,8 @@ COV=99
 SORT=100
 APPEND=101
 TIMESTAMP=102
-BRK=103
-CONT=104
+BREAK=103
+CONTINUE=104
 PLUS=105
 MINUS=106
 MULT=107
diff --git a/more_math/Parser/MathExprListener.py b/more_math/Parser/MathExprListener.py
index 9f5a0cf..7b42bb9 100644
--- a/more_math/Parser/MathExprListener.py
+++ b/more_math/Parser/MathExprListener.py
@@ -44,6 +44,132 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#IfStatement.
+    def enterIfStatement(self, ctx:MathExprParser.IfStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#IfStatement.
+    def exitIfStatement(self, ctx:MathExprParser.IfStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#WhileStatement.
+    def enterWhileStatement(self, ctx:MathExprParser.WhileStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#WhileStatement.
+    def exitWhileStatement(self, ctx:MathExprParser.WhileStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#BlockStatement.
+    def enterBlockStatement(self, ctx:MathExprParser.BlockStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#BlockStatement.
+    def exitBlockStatement(self, ctx:MathExprParser.BlockStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#BreakStatement.
+    def enterBreakStatement(self, ctx:MathExprParser.BreakStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#BreakStatement.
+    def exitBreakStatement(self, ctx:MathExprParser.BreakStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ContinueStatement.
+    def enterContinueStatement(self, ctx:MathExprParser.ContinueStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ContinueStatement.
+    def exitContinueStatement(self, ctx:MathExprParser.ContinueStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ReturnStatement.
+    def enterReturnStatement(self, ctx:MathExprParser.ReturnStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ReturnStatement.
+    def exitReturnStatement(self, ctx:MathExprParser.ReturnStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#VarDefStmt.
+    def enterVarDefStmt(self, ctx:MathExprParser.VarDefStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#VarDefStmt.
+    def exitVarDefStmt(self, ctx:MathExprParser.VarDefStmtContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ExprStatement.
+    def enterExprStatement(self, ctx:MathExprParser.ExprStatementContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ExprStatement.
+    def exitExprStatement(self, ctx:MathExprParser.ExprStatementContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ifStmt.
+    def enterIfStmt(self, ctx:MathExprParser.IfStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ifStmt.
+    def exitIfStmt(self, ctx:MathExprParser.IfStmtContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#whileStmt.
+    def enterWhileStmt(self, ctx:MathExprParser.WhileStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#whileStmt.
+    def exitWhileStmt(self, ctx:MathExprParser.WhileStmtContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#block.
+    def enterBlock(self, ctx:MathExprParser.BlockContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#block.
+    def exitBlock(self, ctx:MathExprParser.BlockContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#breakStmt.
+    def enterBreakStmt(self, ctx:MathExprParser.BreakStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#breakStmt.
+    def exitBreakStmt(self, ctx:MathExprParser.BreakStmtContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#continueStmt.
+    def enterContinueStmt(self, ctx:MathExprParser.ContinueStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#continueStmt.
+    def exitContinueStmt(self, ctx:MathExprParser.ContinueStmtContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#returnStmt.
+    def enterReturnStmt(self, ctx:MathExprParser.ReturnStmtContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#returnStmt.
+    def exitReturnStmt(self, ctx:MathExprParser.ReturnStmtContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#expr.
     def enterExpr(self, ctx:MathExprParser.ExprContext):
         pass
@@ -53,6 +179,15 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#TernaryExp.
+    def enterTernaryExp(self, ctx:MathExprParser.TernaryExpContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#TernaryExp.
+    def exitTernaryExp(self, ctx:MathExprParser.TernaryExpContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#LtExp.
     def enterLtExp(self, ctx:MathExprParser.LtExpContext):
         pass
@@ -242,6 +377,15 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#Func0Exp.
+    def enterFunc0Exp(self, ctx:MathExprParser.Func0ExpContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#Func0Exp.
+    def exitFunc0Exp(self, ctx:MathExprParser.Func0ExpContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#Func1Exp.
     def enterFunc1Exp(self, ctx:MathExprParser.Func1ExpContext):
         pass
@@ -278,6 +422,15 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#Func5Exp.
+    def enterFunc5Exp(self, ctx:MathExprParser.Func5ExpContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#Func5Exp.
+    def exitFunc5Exp(self, ctx:MathExprParser.Func5ExpContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#FuncNExp.
     def enterFuncNExp(self, ctx:MathExprParser.FuncNExpContext):
         pass
@@ -359,6 +512,15 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#TimestampFunc.
+    def enterTimestampFunc(self, ctx:MathExprParser.TimestampFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#TimestampFunc.
+    def exitTimestampFunc(self, ctx:MathExprParser.TimestampFuncContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#SinFunc.
     def enterSinFunc(self, ctx:MathExprParser.SinFuncContext):
         pass
@@ -737,6 +899,105 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#AnyFunc.
+    def enterAnyFunc(self, ctx:MathExprParser.AnyFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#AnyFunc.
+    def exitAnyFunc(self, ctx:MathExprParser.AnyFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#AllFunc.
+    def enterAllFunc(self, ctx:MathExprParser.AllFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#AllFunc.
+    def exitAllFunc(self, ctx:MathExprParser.AllFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#EdgeFunc.
+    def enterEdgeFunc(self, ctx:MathExprParser.EdgeFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#EdgeFunc.
+    def exitEdgeFunc(self, ctx:MathExprParser.EdgeFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#MedianFunc.
+    def enterMedianFunc(self, ctx:MathExprParser.MedianFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#MedianFunc.
+    def exitMedianFunc(self, ctx:MathExprParser.MedianFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ModeFunc.
+    def enterModeFunc(self, ctx:MathExprParser.ModeFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ModeFunc.
+    def exitModeFunc(self, ctx:MathExprParser.ModeFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#CumsumFunc.
+    def enterCumsumFunc(self, ctx:MathExprParser.CumsumFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#CumsumFunc.
+    def exitCumsumFunc(self, ctx:MathExprParser.CumsumFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#CumprodFunc.
+    def enterCumprodFunc(self, ctx:MathExprParser.CumprodFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#CumprodFunc.
+    def exitCumprodFunc(self, ctx:MathExprParser.CumprodFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#PopFunc.
+    def enterPopFunc(self, ctx:MathExprParser.PopFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#PopFunc.
+    def exitPopFunc(self, ctx:MathExprParser.PopFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ClearFunc.
+    def enterClearFunc(self, ctx:MathExprParser.ClearFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ClearFunc.
+    def exitClearFunc(self, ctx:MathExprParser.ClearFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#HasFunc.
+    def enterHasFunc(self, ctx:MathExprParser.HasFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#HasFunc.
+    def exitHasFunc(self, ctx:MathExprParser.HasFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#GetFunc.
+    def enterGetFunc(self, ctx:MathExprParser.GetFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#GetFunc.
+    def exitGetFunc(self, ctx:MathExprParser.GetFuncContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#PowFunc.
     def enterPowFunc(self, ctx:MathExprParser.PowFuncContext):
         pass
@@ -899,6 +1160,42 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#GaussianFunc.
+    def enterGaussianFunc(self, ctx:MathExprParser.GaussianFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#GaussianFunc.
+    def exitGaussianFunc(self, ctx:MathExprParser.GaussianFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#TopkIndFunc.
+    def enterTopkIndFunc(self, ctx:MathExprParser.TopkIndFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#TopkIndFunc.
+    def exitTopkIndFunc(self, ctx:MathExprParser.TopkIndFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#BotkIndFunc.
+    def enterBotkIndFunc(self, ctx:MathExprParser.BotkIndFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#BotkIndFunc.
+    def exitBotkIndFunc(self, ctx:MathExprParser.BotkIndFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#PushFunc.
+    def enterPushFunc(self, ctx:MathExprParser.PushFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#PushFunc.
+    def exitPushFunc(self, ctx:MathExprParser.PushFuncContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#ClampFunc.
     def enterClampFunc(self, ctx:MathExprParser.ClampFuncContext):
         pass
@@ -962,6 +1259,42 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#CubicEaseFunc.
+    def enterCubicEaseFunc(self, ctx:MathExprParser.CubicEaseFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#CubicEaseFunc.
+    def exitCubicEaseFunc(self, ctx:MathExprParser.CubicEaseFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#ElasticEaseFunc.
+    def enterElasticEaseFunc(self, ctx:MathExprParser.ElasticEaseFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#ElasticEaseFunc.
+    def exitElasticEaseFunc(self, ctx:MathExprParser.ElasticEaseFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#SineEaseFunc.
+    def enterSineEaseFunc(self, ctx:MathExprParser.SineEaseFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#SineEaseFunc.
+    def exitSineEaseFunc(self, ctx:MathExprParser.SineEaseFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#SmootherstepFunc.
+    def enterSmootherstepFunc(self, ctx:MathExprParser.SmootherstepFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#SmootherstepFunc.
+    def exitSmootherstepFunc(self, ctx:MathExprParser.SmootherstepFuncContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#SwapFunc.
     def enterSwapFunc(self, ctx:MathExprParser.SwapFuncContext):
         pass
@@ -980,6 +1313,24 @@ class MathExprListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by MathExprParser#DistFunc.
+    def enterDistFunc(self, ctx:MathExprParser.DistFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#DistFunc.
+    def exitDistFunc(self, ctx:MathExprParser.DistFuncContext):
+        pass
+
+
+    # Enter a parse tree produced by MathExprParser#RemapFunc.
+    def enterRemapFunc(self, ctx:MathExprParser.RemapFuncContext):
+        pass
+
+    # Exit a parse tree produced by MathExprParser#RemapFunc.
+    def exitRemapFunc(self, ctx:MathExprParser.RemapFuncContext):
+        pass
+
+
     # Enter a parse tree produced by MathExprParser#SMinFunc.
     def enterSMinFunc(self, ctx:MathExprParser.SMinFuncContext):
         pass
diff --git a/more_math/Parser/MathExprParser.py b/more_math/Parser/MathExprParser.py
index ee23a47..9cfa907 100644
--- a/more_math/Parser/MathExprParser.py
+++ b/more_math/Parser/MathExprParser.py
@@ -419,15 +419,15 @@ class MathExprParser ( Parser ):
                       "GAUSSIAN", "MEDIAN", "MODE", "CUMSUM", "CUMPROD", 
                       "TOPK_IND", "BOTK_IND", "CUBIC_EASE", "ELASTIC_EASE", 
                       "SINE_EASE", "SMOOTHERSTEP", "DIST", "REMAP", "IF", 
-                      "ELSE", "WHILE", "RET", "PUSH", "POP", "CLEAR", "HAS", 
-                      "GET", "NOISE", "RAND", "CAUCHY", "EXPONENTIAL", "LOGNORMAL", 
-                      "BERNOULLI", "POISSON", "COSSIM", "FLIP", "COV", "SORT", 
-                      "APPEND", "TIMESTAMP", "BRK", "CONT", "PLUS", "MINUS", 
-                      "MULT", "DIV", "MOD", "POW", "GE", "GT", "LE", "LT", 
-                      "EQ", "EQUEALS", "NE", "PIPE", "LPAREN", "RPAREN", 
-                      "COMMA", "SEMICOLON", "ARROW", "LBRACKET", "RBRACKET", 
-                      "QUESTION", "COLON", "LBRACE", "RBRACE", "CONSTANT", 
-                      "NUMBER", "VARIABLE", "SL_COMMENT", "ML_COMMENT", 
+                      "ELSE", "WHILE", "RETURN", "PUSH", "POP", "CLEAR", 
+                      "HAS", "GET", "NOISE", "RAND", "CAUCHY", "EXPONENTIAL", 
+                      "LOGNORMAL", "BERNOULLI", "POISSON", "COSSIM", "FLIP", 
+                      "COV", "SORT", "APPEND", "TIMESTAMP", "BREAK", "CONTINUE", 
+                      "PLUS", "MINUS", "MULT", "DIV", "MOD", "POW", "GE", 
+                      "GT", "LE", "LT", "EQ", "EQUEALS", "NE", "PIPE", "LPAREN", 
+                      "RPAREN", "COMMA", "SEMICOLON", "ARROW", "LBRACKET", 
+                      "RBRACKET", "QUESTION", "COLON", "LBRACE", "RBRACE", 
+                      "CONSTANT", "NUMBER", "VARIABLE", "SL_COMMENT", "ML_COMMENT", 
                       "WS" ]
 
     RULE_start = 0
@@ -550,7 +550,7 @@ class MathExprParser ( Parser ):
     IF=81
     ELSE=82
     WHILE=83
-    RET=84
+    RETURN=84
     PUSH=85
     POP=86
     CLEAR=87
@@ -569,8 +569,8 @@ class MathExprParser ( Parser ):
     SORT=100
     APPEND=101
     TIMESTAMP=102
-    BRK=103
-    CONT=104
+    BREAK=103
+    CONTINUE=104
     PLUS=105
     MINUS=106
     MULT=107
@@ -650,6 +650,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_start
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStart" ):
+                listener.enterStart(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStart" ):
+                listener.exitStart(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitStart" ):
                 return visitor.visitStart(self)
@@ -749,6 +757,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.ParamListContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunctionDef" ):
+                listener.enterFunctionDef(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunctionDef" ):
+                listener.exitFunctionDef(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunctionDef" ):
                 return visitor.visitFunctionDef(self)
@@ -829,6 +845,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_varDef
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterVarDef" ):
+                listener.enterVarDef(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitVarDef" ):
+                listener.exitVarDef(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitVarDef" ):
                 return visitor.visitVarDef(self)
@@ -883,6 +907,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_paramList
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParamList" ):
+                listener.enterParamList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParamList" ):
+                listener.exitParamList(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitParamList" ):
                 return visitor.visitParamList(self)
@@ -949,6 +981,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.BreakStmtContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBreakStatement" ):
+                listener.enterBreakStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBreakStatement" ):
+                listener.exitBreakStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBreakStatement" ):
                 return visitor.visitBreakStatement(self)
@@ -966,6 +1006,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.VarDefContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterVarDefStmt" ):
+                listener.enterVarDefStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitVarDefStmt" ):
+                listener.exitVarDefStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitVarDefStmt" ):
                 return visitor.visitVarDefStmt(self)
@@ -983,6 +1031,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.IfStmtContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIfStatement" ):
+                listener.enterIfStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIfStatement" ):
+                listener.exitIfStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitIfStatement" ):
                 return visitor.visitIfStatement(self)
@@ -1000,6 +1056,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.ReturnStmtContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterReturnStatement" ):
+                listener.enterReturnStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitReturnStatement" ):
+                listener.exitReturnStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitReturnStatement" ):
                 return visitor.visitReturnStatement(self)
@@ -1019,6 +1083,14 @@ class MathExprParser ( Parser ):
         def SEMICOLON(self):
             return self.getToken(MathExprParser.SEMICOLON, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExprStatement" ):
+                listener.enterExprStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExprStatement" ):
+                listener.exitExprStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitExprStatement" ):
                 return visitor.visitExprStatement(self)
@@ -1036,6 +1108,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.BlockContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBlockStatement" ):
+                listener.enterBlockStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBlockStatement" ):
+                listener.exitBlockStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBlockStatement" ):
                 return visitor.visitBlockStatement(self)
@@ -1053,6 +1133,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.WhileStmtContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterWhileStatement" ):
+                listener.enterWhileStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitWhileStatement" ):
+                listener.exitWhileStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitWhileStatement" ):
                 return visitor.visitWhileStatement(self)
@@ -1070,6 +1158,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.ContinueStmtContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterContinueStatement" ):
+                listener.enterContinueStatement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitContinueStatement" ):
+                listener.exitContinueStatement(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitContinueStatement" ):
                 return visitor.visitContinueStatement(self)
@@ -1187,6 +1283,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_ifStmt
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIfStmt" ):
+                listener.enterIfStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIfStmt" ):
+                listener.exitIfStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitIfStmt" ):
                 return visitor.visitIfStmt(self)
@@ -1258,6 +1362,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_whileStmt
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterWhileStmt" ):
+                listener.enterWhileStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitWhileStmt" ):
+                listener.exitWhileStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitWhileStmt" ):
                 return visitor.visitWhileStmt(self)
@@ -1315,6 +1427,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_block
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBlock" ):
+                listener.enterBlock(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBlock" ):
+                listener.exitBlock(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBlock" ):
                 return visitor.visitBlock(self)
@@ -1361,8 +1481,8 @@ class MathExprParser ( Parser ):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def BRK(self):
-            return self.getToken(MathExprParser.BRK, 0)
+        def BREAK(self):
+            return self.getToken(MathExprParser.BREAK, 0)
 
         def SEMICOLON(self):
             return self.getToken(MathExprParser.SEMICOLON, 0)
@@ -1370,6 +1490,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_breakStmt
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBreakStmt" ):
+                listener.enterBreakStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBreakStmt" ):
+                listener.exitBreakStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBreakStmt" ):
                 return visitor.visitBreakStmt(self)
@@ -1386,7 +1514,7 @@ class MathExprParser ( Parser ):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 129
-            self.match(MathExprParser.BRK)
+            self.match(MathExprParser.BREAK)
             self.state = 130
             self.match(MathExprParser.SEMICOLON)
         except RecognitionException as re:
@@ -1405,8 +1533,8 @@ class MathExprParser ( Parser ):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CONT(self):
-            return self.getToken(MathExprParser.CONT, 0)
+        def CONTINUE(self):
+            return self.getToken(MathExprParser.CONTINUE, 0)
 
         def SEMICOLON(self):
             return self.getToken(MathExprParser.SEMICOLON, 0)
@@ -1414,6 +1542,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_continueStmt
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterContinueStmt" ):
+                listener.enterContinueStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitContinueStmt" ):
+                listener.exitContinueStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitContinueStmt" ):
                 return visitor.visitContinueStmt(self)
@@ -1430,7 +1566,7 @@ class MathExprParser ( Parser ):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 132
-            self.match(MathExprParser.CONT)
+            self.match(MathExprParser.CONTINUE)
             self.state = 133
             self.match(MathExprParser.SEMICOLON)
         except RecognitionException as re:
@@ -1449,8 +1585,8 @@ class MathExprParser ( Parser ):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def RET(self):
-            return self.getToken(MathExprParser.RET, 0)
+        def RETURN(self):
+            return self.getToken(MathExprParser.RETURN, 0)
 
         def SEMICOLON(self):
             return self.getToken(MathExprParser.SEMICOLON, 0)
@@ -1462,6 +1598,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_returnStmt
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterReturnStmt" ):
+                listener.enterReturnStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitReturnStmt" ):
+                listener.exitReturnStmt(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitReturnStmt" ):
                 return visitor.visitReturnStmt(self)
@@ -1479,7 +1623,7 @@ class MathExprParser ( Parser ):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 135
-            self.match(MathExprParser.RET)
+            self.match(MathExprParser.RETURN)
             self.state = 137
             self._errHandler.sync(self)
             _la = self._input.LA(1)
@@ -1521,6 +1665,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_expr
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExpr" ):
+                listener.enterExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExpr" ):
+                listener.exitExpr(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitExpr" ):
                 return visitor.visitExpr(self)
@@ -1603,6 +1755,14 @@ class MathExprParser ( Parser ):
         def COLON(self):
             return self.getToken(MathExprParser.COLON, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTernaryExp" ):
+                listener.enterTernaryExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTernaryExp" ):
+                listener.exitTernaryExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTernaryExp" ):
                 return visitor.visitTernaryExp(self)
@@ -1668,6 +1828,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLtExp" ):
+                listener.enterLtExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLtExp" ):
+                listener.exitLtExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLtExp" ):
                 return visitor.visitLtExp(self)
@@ -1690,6 +1858,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEqExp" ):
+                listener.enterEqExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEqExp" ):
+                listener.exitEqExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitEqExp" ):
                 return visitor.visitEqExp(self)
@@ -1707,6 +1883,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToAdd" ):
+                listener.enterToAdd(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToAdd" ):
+                listener.exitToAdd(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToAdd" ):
                 return visitor.visitToAdd(self)
@@ -1729,6 +1913,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGeExp" ):
+                listener.enterGeExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGeExp" ):
+                listener.exitGeExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGeExp" ):
                 return visitor.visitGeExp(self)
@@ -1751,6 +1943,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLeExp" ):
+                listener.enterLeExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLeExp" ):
+                listener.exitLeExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLeExp" ):
                 return visitor.visitLeExp(self)
@@ -1773,6 +1973,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNeExp" ):
+                listener.enterNeExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNeExp" ):
+                listener.exitNeExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitNeExp" ):
                 return visitor.visitNeExp(self)
@@ -1795,6 +2003,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AddExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGtExp" ):
+                listener.enterGtExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGtExp" ):
+                listener.exitGtExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGtExp" ):
                 return visitor.visitGtExp(self)
@@ -1953,6 +2169,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAddExp" ):
+                listener.enterAddExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAddExp" ):
+                listener.exitAddExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAddExp" ):
                 return visitor.visitAddExp(self)
@@ -1970,6 +2194,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToMul" ):
+                listener.enterToMul(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToMul" ):
+                listener.exitToMul(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToMul" ):
                 return visitor.visitToMul(self)
@@ -1992,6 +2224,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.MulExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSubExp" ):
+                listener.enterSubExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSubExp" ):
+                listener.exitSubExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSubExp" ):
                 return visitor.visitSubExp(self)
@@ -2098,6 +2338,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMulExp" ):
+                listener.enterMulExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMulExp" ):
+                listener.exitMulExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitMulExp" ):
                 return visitor.visitMulExp(self)
@@ -2120,6 +2368,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterModExp" ):
+                listener.enterModExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitModExp" ):
+                listener.exitModExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitModExp" ):
                 return visitor.visitModExp(self)
@@ -2142,6 +2398,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDivExp" ):
+                listener.enterDivExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDivExp" ):
+                listener.exitDivExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitDivExp" ):
                 return visitor.visitDivExp(self)
@@ -2159,6 +2423,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToPow" ):
+                listener.enterToPow(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToPow" ):
+                listener.exitToPow(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToPow" ):
                 return visitor.visitToPow(self)
@@ -2279,6 +2551,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.PowExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPowExp" ):
+                listener.enterPowExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPowExp" ):
+                listener.exitPowExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPowExp" ):
                 return visitor.visitPowExp(self)
@@ -2296,6 +2576,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToUnary" ):
+                listener.enterToUnary(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToUnary" ):
+                listener.exitToUnary(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToUnary" ):
                 return visitor.visitToUnary(self)
@@ -2369,6 +2657,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryPlus" ):
+                listener.enterUnaryPlus(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryPlus" ):
+                listener.exitUnaryPlus(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitUnaryPlus" ):
                 return visitor.visitUnaryPlus(self)
@@ -2388,6 +2684,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.UnaryExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryMinus" ):
+                listener.enterUnaryMinus(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryMinus" ):
+                listener.exitUnaryMinus(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitUnaryMinus" ):
                 return visitor.visitUnaryMinus(self)
@@ -2405,6 +2709,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.IndexExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToIndex" ):
+                listener.enterToIndex(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToIndex" ):
+                listener.exitToIndex(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToIndex" ):
                 return visitor.visitToIndex(self)
@@ -2496,6 +2808,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIndexExp" ):
+                listener.enterIndexExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIndexExp" ):
+                listener.exitIndexExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitIndexExp" ):
                 return visitor.visitIndexExp(self)
@@ -2513,6 +2833,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.AtomContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterToAtom" ):
+                listener.enterToAtom(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitToAtom" ):
+                listener.exitToAtom(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitToAtom" ):
                 return visitor.visitToAtom(self)
@@ -2610,6 +2938,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func5Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc5Exp" ):
+                listener.enterFunc5Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc5Exp" ):
+                listener.exitFunc5Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc5Exp" ):
                 return visitor.visitFunc5Exp(self)
@@ -2627,6 +2963,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func4Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc4Exp" ):
+                listener.enterFunc4Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc4Exp" ):
+                listener.exitFunc4Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc4Exp" ):
                 return visitor.visitFunc4Exp(self)
@@ -2644,6 +2988,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func2Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc2Exp" ):
+                listener.enterFunc2Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc2Exp" ):
+                listener.exitFunc2Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc2Exp" ):
                 return visitor.visitFunc2Exp(self)
@@ -2661,6 +3013,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func3Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc3Exp" ):
+                listener.enterFunc3Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc3Exp" ):
+                listener.exitFunc3Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc3Exp" ):
                 return visitor.visitFunc3Exp(self)
@@ -2677,6 +3037,14 @@ class MathExprParser ( Parser ):
         def CONSTANT(self):
             return self.getToken(MathExprParser.CONSTANT, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConstantExp" ):
+                listener.enterConstantExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConstantExp" ):
+                listener.exitConstantExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitConstantExp" ):
                 return visitor.visitConstantExp(self)
@@ -2694,6 +3062,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.FuncNContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFuncNExp" ):
+                listener.enterFuncNExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFuncNExp" ):
+                listener.exitFuncNExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFuncNExp" ):
                 return visitor.visitFuncNExp(self)
@@ -2716,6 +3092,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.ExprContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAbsExp" ):
+                listener.enterAbsExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAbsExp" ):
+                listener.exitAbsExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAbsExp" ):
                 return visitor.visitAbsExp(self)
@@ -2745,6 +3129,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterListExp" ):
+                listener.enterListExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitListExp" ):
+                listener.exitListExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitListExp" ):
                 return visitor.visitListExp(self)
@@ -2761,6 +3153,14 @@ class MathExprParser ( Parser ):
         def VARIABLE(self):
             return self.getToken(MathExprParser.VARIABLE, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterVariableExp" ):
+                listener.enterVariableExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitVariableExp" ):
+                listener.exitVariableExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitVariableExp" ):
                 return visitor.visitVariableExp(self)
@@ -2784,6 +3184,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.ExprListContext,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCallExp" ):
+                listener.enterCallExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCallExp" ):
+                listener.exitCallExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCallExp" ):
                 return visitor.visitCallExp(self)
@@ -2805,6 +3213,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParenExp" ):
+                listener.enterParenExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParenExp" ):
+                listener.exitParenExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitParenExp" ):
                 return visitor.visitParenExp(self)
@@ -2822,6 +3238,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func1Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc1Exp" ):
+                listener.enterFunc1Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc1Exp" ):
+                listener.exitFunc1Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc1Exp" ):
                 return visitor.visitFunc1Exp(self)
@@ -2839,6 +3263,14 @@ class MathExprParser ( Parser ):
             return self.getTypedRuleContext(MathExprParser.Func0Context,0)
 
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunc0Exp" ):
+                listener.enterFunc0Exp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunc0Exp" ):
+                listener.exitFunc0Exp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFunc0Exp" ):
                 return visitor.visitFunc0Exp(self)
@@ -2855,6 +3287,14 @@ class MathExprParser ( Parser ):
         def NUMBER(self):
             return self.getToken(MathExprParser.NUMBER, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNumberExp" ):
+                listener.enterNumberExp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNumberExp" ):
+                listener.exitNumberExp(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitNumberExp" ):
                 return visitor.visitNumberExp(self)
@@ -3039,6 +3479,14 @@ class MathExprParser ( Parser ):
         def getRuleIndex(self):
             return MathExprParser.RULE_exprList
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExprList" ):
+                listener.enterExprList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExprList" ):
+                listener.exitExprList(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitExprList" ):
                 return visitor.visitExprList(self)
@@ -3108,6 +3556,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTimestampFunc" ):
+                listener.enterTimestampFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTimestampFunc" ):
+                listener.exitTimestampFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTimestampFunc" ):
                 return visitor.visitTimestampFunc(self)
@@ -3171,6 +3627,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSoftplusFunc" ):
+                listener.enterSoftplusFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSoftplusFunc" ):
+                listener.exitSoftplusFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSoftplusFunc" ):
                 return visitor.visitSoftplusFunc(self)
@@ -3194,6 +3658,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAcoshFunc" ):
+                listener.enterAcoshFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAcoshFunc" ):
+                listener.exitAcoshFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAcoshFunc" ):
                 return visitor.visitAcoshFunc(self)
@@ -3217,6 +3689,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNoiseFunc" ):
+                listener.enterNoiseFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNoiseFunc" ):
+                listener.exitNoiseFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitNoiseFunc" ):
                 return visitor.visitNoiseFunc(self)
@@ -3240,6 +3720,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSqrtFunc" ):
+                listener.enterSqrtFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSqrtFunc" ):
+                listener.exitSqrtFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSqrtFunc" ):
                 return visitor.visitSqrtFunc(self)
@@ -3263,6 +3751,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFloorFunc" ):
+                listener.enterFloorFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFloorFunc" ):
+                listener.exitFloorFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFloorFunc" ):
                 return visitor.visitFloorFunc(self)
@@ -3286,6 +3782,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMeanFunc" ):
+                listener.enterMeanFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMeanFunc" ):
+                listener.exitMeanFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitMeanFunc" ):
                 return visitor.visitMeanFunc(self)
@@ -3309,6 +3813,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCeilFunc" ):
+                listener.enterCeilFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCeilFunc" ):
+                listener.exitCeilFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCeilFunc" ):
                 return visitor.visitCeilFunc(self)
@@ -3332,6 +3844,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAbsFunc" ):
+                listener.enterAbsFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAbsFunc" ):
+                listener.exitAbsFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAbsFunc" ):
                 return visitor.visitAbsFunc(self)
@@ -3355,6 +3875,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAtanFunc" ):
+                listener.enterAtanFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAtanFunc" ):
+                listener.exitAtanFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAtanFunc" ):
                 return visitor.visitAtanFunc(self)
@@ -3378,6 +3906,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSinhFunc" ):
+                listener.enterSinhFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSinhFunc" ):
+                listener.exitSinhFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSinhFunc" ):
                 return visitor.visitSinhFunc(self)
@@ -3401,6 +3937,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSigmoidFunc" ):
+                listener.enterSigmoidFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSigmoidFunc" ):
+                listener.exitSigmoidFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSigmoidFunc" ):
                 return visitor.visitSigmoidFunc(self)
@@ -3424,6 +3968,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLogFunc" ):
+                listener.enterLogFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLogFunc" ):
+                listener.exitLogFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLogFunc" ):
                 return visitor.visitLogFunc(self)
@@ -3447,6 +3999,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTNormFunc" ):
+                listener.enterTNormFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTNormFunc" ):
+                listener.exitTNormFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTNormFunc" ):
                 return visitor.visitTNormFunc(self)
@@ -3470,6 +4030,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSinFunc" ):
+                listener.enterSinFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSinFunc" ):
+                listener.exitSinFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSinFunc" ):
                 return visitor.visitSinFunc(self)
@@ -3493,6 +4061,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterRandFunc" ):
+                listener.enterRandFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitRandFunc" ):
+                listener.exitRandFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitRandFunc" ):
                 return visitor.visitRandFunc(self)
@@ -3516,6 +4092,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAcosFunc" ):
+                listener.enterAcosFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAcosFunc" ):
+                listener.exitAcosFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAcosFunc" ):
                 return visitor.visitAcosFunc(self)
@@ -3539,6 +4123,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCoshFunc" ):
+                listener.enterCoshFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCoshFunc" ):
+                listener.exitCoshFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCoshFunc" ):
                 return visitor.visitCoshFunc(self)
@@ -3562,6 +4154,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAnglFunc" ):
+                listener.enterAnglFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAnglFunc" ):
+                listener.exitAnglFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAnglFunc" ):
                 return visitor.visitAnglFunc(self)
@@ -3585,6 +4185,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCumsumFunc" ):
+                listener.enterCumsumFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCumsumFunc" ):
+                listener.exitCumsumFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCumsumFunc" ):
                 return visitor.visitCumsumFunc(self)
@@ -3608,6 +4216,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGetFunc" ):
+                listener.enterGetFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGetFunc" ):
+                listener.exitGetFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGetFunc" ):
                 return visitor.visitGetFunc(self)
@@ -3631,6 +4247,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSignFunc" ):
+                listener.enterSignFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSignFunc" ):
+                listener.exitSignFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSignFunc" ):
                 return visitor.visitSignFunc(self)
@@ -3654,6 +4278,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTanFunc" ):
+                listener.enterTanFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTanFunc" ):
+                listener.exitTanFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTanFunc" ):
                 return visitor.visitTanFunc(self)
@@ -3677,6 +4309,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPinvFunc" ):
+                listener.enterPinvFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPinvFunc" ):
+                listener.exitPinvFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPinvFunc" ):
                 return visitor.visitPinvFunc(self)
@@ -3700,6 +4340,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFractFunc" ):
+                listener.enterFractFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFractFunc" ):
+                listener.exitFractFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFractFunc" ):
                 return visitor.visitFractFunc(self)
@@ -3723,6 +4371,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGammaFunc" ):
+                listener.enterGammaFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGammaFunc" ):
+                listener.exitGammaFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGammaFunc" ):
                 return visitor.visitGammaFunc(self)
@@ -3746,6 +4402,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterVarFunc" ):
+                listener.enterVarFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitVarFunc" ):
+                listener.exitVarFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitVarFunc" ):
                 return visitor.visitVarFunc(self)
@@ -3769,6 +4433,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAsinFunc" ):
+                listener.enterAsinFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAsinFunc" ):
+                listener.exitAsinFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAsinFunc" ):
                 return visitor.visitAsinFunc(self)
@@ -3792,6 +4464,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAsinhFunc" ):
+                listener.enterAsinhFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAsinhFunc" ):
+                listener.exitAsinhFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAsinhFunc" ):
                 return visitor.visitAsinhFunc(self)
@@ -3815,6 +4495,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSfftFunc" ):
+                listener.enterSfftFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSfftFunc" ):
+                listener.exitSfftFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSfftFunc" ):
                 return visitor.visitSfftFunc(self)
@@ -3838,6 +4526,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAllFunc" ):
+                listener.enterAllFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAllFunc" ):
+                listener.exitAllFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAllFunc" ):
                 return visitor.visitAllFunc(self)
@@ -3861,6 +4557,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAtanhFunc" ):
+                listener.enterAtanhFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAtanhFunc" ):
+                listener.exitAtanhFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAtanhFunc" ):
                 return visitor.visitAtanhFunc(self)
@@ -3884,6 +4588,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterClearFunc" ):
+                listener.enterClearFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitClearFunc" ):
+                listener.exitClearFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitClearFunc" ):
                 return visitor.visitClearFunc(self)
@@ -3907,6 +4619,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPopFunc" ):
+                listener.enterPopFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPopFunc" ):
+                listener.exitPopFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPopFunc" ):
                 return visitor.visitPopFunc(self)
@@ -3930,6 +4650,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMedianFunc" ):
+                listener.enterMedianFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMedianFunc" ):
+                listener.exitMedianFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitMedianFunc" ):
                 return visitor.visitMedianFunc(self)
@@ -3953,6 +4681,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrintShapeFunc" ):
+                listener.enterPrintShapeFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrintShapeFunc" ):
+                listener.exitPrintShapeFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPrintShapeFunc" ):
                 return visitor.visitPrintShapeFunc(self)
@@ -3976,6 +4712,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSortFunc" ):
+                listener.enterSortFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSortFunc" ):
+                listener.exitSortFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSortFunc" ):
                 return visitor.visitSortFunc(self)
@@ -3999,6 +4743,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTanhFunc" ):
+                listener.enterTanhFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTanhFunc" ):
+                listener.exitTanhFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTanhFunc" ):
                 return visitor.visitTanhFunc(self)
@@ -4022,6 +4774,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAnyFunc" ):
+                listener.enterAnyFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAnyFunc" ):
+                listener.exitAnyFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAnyFunc" ):
                 return visitor.visitAnyFunc(self)
@@ -4045,6 +4805,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterModeFunc" ):
+                listener.enterModeFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitModeFunc" ):
+                listener.exitModeFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitModeFunc" ):
                 return visitor.visitModeFunc(self)
@@ -4068,6 +4836,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterRoundFunc" ):
+                listener.enterRoundFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitRoundFunc" ):
+                listener.exitRoundFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitRoundFunc" ):
                 return visitor.visitRoundFunc(self)
@@ -4091,6 +4867,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGeluFunc" ):
+                listener.enterGeluFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGeluFunc" ):
+                listener.exitGeluFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGeluFunc" ):
                 return visitor.visitGeluFunc(self)
@@ -4114,6 +4898,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrintFunc" ):
+                listener.enterPrintFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrintFunc" ):
+                listener.exitPrintFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPrintFunc" ):
                 return visitor.visitPrintFunc(self)
@@ -4137,6 +4929,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterReluFunc" ):
+                listener.enterReluFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitReluFunc" ):
+                listener.exitReluFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitReluFunc" ):
                 return visitor.visitReluFunc(self)
@@ -4165,6 +4965,14 @@ class MathExprParser ( Parser ):
         def COMMA(self):
             return self.getToken(MathExprParser.COMMA, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEdgeFunc" ):
+                listener.enterEdgeFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEdgeFunc" ):
+                listener.exitEdgeFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitEdgeFunc" ):
                 return visitor.visitEdgeFunc(self)
@@ -4188,6 +4996,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLnFunc" ):
+                listener.enterLnFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLnFunc" ):
+                listener.exitLnFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLnFunc" ):
                 return visitor.visitLnFunc(self)
@@ -4211,6 +5027,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSNormFunc" ):
+                listener.enterSNormFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSNormFunc" ):
+                listener.exitSNormFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSNormFunc" ):
                 return visitor.visitSNormFunc(self)
@@ -4234,6 +5058,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStdFunc" ):
+                listener.enterStdFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStdFunc" ):
+                listener.exitStdFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitStdFunc" ):
                 return visitor.visitStdFunc(self)
@@ -4257,6 +5089,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSumFunc" ):
+                listener.enterSumFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSumFunc" ):
+                listener.exitSumFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSumFunc" ):
                 return visitor.visitSumFunc(self)
@@ -4280,6 +5120,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterHasFunc" ):
+                listener.enterHasFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitHasFunc" ):
+                listener.exitHasFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitHasFunc" ):
                 return visitor.visitHasFunc(self)
@@ -4303,6 +5151,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSifftFunc" ):
+                listener.enterSifftFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSifftFunc" ):
+                listener.exitSifftFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSifftFunc" ):
                 return visitor.visitSifftFunc(self)
@@ -4326,6 +5182,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCosFunc" ):
+                listener.enterCosFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCosFunc" ):
+                listener.exitCosFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCosFunc" ):
                 return visitor.visitCosFunc(self)
@@ -4349,6 +5213,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCumprodFunc" ):
+                listener.enterCumprodFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCumprodFunc" ):
+                listener.exitCumprodFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCumprodFunc" ):
                 return visitor.visitCumprodFunc(self)
@@ -4372,6 +5244,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExpFunc" ):
+                listener.enterExpFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExpFunc" ):
+                listener.exitExpFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitExpFunc" ):
                 return visitor.visitExpFunc(self)
@@ -5085,6 +5965,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTopkFunc" ):
+                listener.enterTopkFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTopkFunc" ):
+                listener.exitTopkFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTopkFunc" ):
                 return visitor.visitTopkFunc(self)
@@ -5113,6 +6001,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPercentileFunc" ):
+                listener.enterPercentileFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPercentileFunc" ):
+                listener.exitPercentileFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPercentileFunc" ):
                 return visitor.visitPercentileFunc(self)
@@ -5141,6 +6037,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTopkIndFunc" ):
+                listener.enterTopkIndFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTopkIndFunc" ):
+                listener.exitTopkIndFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTopkIndFunc" ):
                 return visitor.visitTopkIndFunc(self)
@@ -5169,6 +6073,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExponentialFunc" ):
+                listener.enterExponentialFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExponentialFunc" ):
+                listener.exitExponentialFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitExponentialFunc" ):
                 return visitor.visitExponentialFunc(self)
@@ -5197,6 +6109,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPoissonFunc" ):
+                listener.enterPoissonFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPoissonFunc" ):
+                listener.exitPoissonFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPoissonFunc" ):
                 return visitor.visitPoissonFunc(self)
@@ -5225,6 +6145,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCovFunc" ):
+                listener.enterCovFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCovFunc" ):
+                listener.exitCovFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCovFunc" ):
                 return visitor.visitCovFunc(self)
@@ -5253,6 +6181,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBernoulliFunc" ):
+                listener.enterBernoulliFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBernoulliFunc" ):
+                listener.exitBernoulliFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBernoulliFunc" ):
                 return visitor.visitBernoulliFunc(self)
@@ -5281,6 +6217,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStepFunc" ):
+                listener.enterStepFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStepFunc" ):
+                listener.exitStepFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitStepFunc" ):
                 return visitor.visitStepFunc(self)
@@ -5309,6 +6253,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAtan2Func" ):
+                listener.enterAtan2Func(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAtan2Func" ):
+                listener.exitAtan2Func(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAtan2Func" ):
                 return visitor.visitAtan2Func(self)
@@ -5337,6 +6289,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuantileFunc" ):
+                listener.enterQuantileFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuantileFunc" ):
+                listener.exitQuantileFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitQuantileFunc" ):
                 return visitor.visitQuantileFunc(self)
@@ -5365,6 +6325,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBotkFunc" ):
+                listener.enterBotkFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBotkFunc" ):
+                listener.exitBotkFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBotkFunc" ):
                 return visitor.visitBotkFunc(self)
@@ -5393,6 +6361,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTMaxFunc" ):
+                listener.enterTMaxFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTMaxFunc" ):
+                listener.exitTMaxFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTMaxFunc" ):
                 return visitor.visitTMaxFunc(self)
@@ -5421,6 +6397,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPushFunc" ):
+                listener.enterPushFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPushFunc" ):
+                listener.exitPushFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPushFunc" ):
                 return visitor.visitPushFunc(self)
@@ -5449,6 +6433,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCossimFunc" ):
+                listener.enterCossimFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCossimFunc" ):
+                listener.exitCossimFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCossimFunc" ):
                 return visitor.visitCossimFunc(self)
@@ -5477,6 +6469,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBotkIndFunc" ):
+                listener.enterBotkIndFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBotkIndFunc" ):
+                listener.exitBotkIndFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBotkIndFunc" ):
                 return visitor.visitBotkIndFunc(self)
@@ -5505,6 +6505,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPowFunc" ):
+                listener.enterPowFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPowFunc" ):
+                listener.exitPowFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPowFunc" ):
                 return visitor.visitPowFunc(self)
@@ -5533,6 +6541,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDotFunc" ):
+                listener.enterDotFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDotFunc" ):
+                listener.exitDotFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitDotFunc" ):
                 return visitor.visitDotFunc(self)
@@ -5561,6 +6577,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAppendFunc" ):
+                listener.enterAppendFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAppendFunc" ):
+                listener.exitAppendFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitAppendFunc" ):
                 return visitor.visitAppendFunc(self)
@@ -5592,6 +6616,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGaussianFunc" ):
+                listener.enterGaussianFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGaussianFunc" ):
+                listener.exitGaussianFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitGaussianFunc" ):
                 return visitor.visitGaussianFunc(self)
@@ -5620,6 +6652,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFlipFunc" ):
+                listener.enterFlipFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFlipFunc" ):
+                listener.exitFlipFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitFlipFunc" ):
                 return visitor.visitFlipFunc(self)
@@ -5648,6 +6688,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuartileFunc" ):
+                listener.enterQuartileFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuartileFunc" ):
+                listener.exitQuartileFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitQuartileFunc" ):
                 return visitor.visitQuartileFunc(self)
@@ -5676,6 +6724,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTMinFunc" ):
+                listener.enterTMinFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTMinFunc" ):
+                listener.exitTMinFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitTMinFunc" ):
                 return visitor.visitTMinFunc(self)
@@ -6108,6 +7164,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSmootherstepFunc" ):
+                listener.enterSmootherstepFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSmootherstepFunc" ):
+                listener.exitSmootherstepFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSmootherstepFunc" ):
                 return visitor.visitSmootherstepFunc(self)
@@ -6139,6 +7203,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMomentFunc" ):
+                listener.enterMomentFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMomentFunc" ):
+                listener.exitMomentFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitMomentFunc" ):
                 return visitor.visitMomentFunc(self)
@@ -6170,6 +7242,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCubicEaseFunc" ):
+                listener.enterCubicEaseFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCubicEaseFunc" ):
+                listener.exitCubicEaseFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCubicEaseFunc" ):
                 return visitor.visitCubicEaseFunc(self)
@@ -6201,6 +7281,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLerpFunc" ):
+                listener.enterLerpFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLerpFunc" ):
+                listener.exitLerpFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLerpFunc" ):
                 return visitor.visitLerpFunc(self)
@@ -6232,6 +7320,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSmoothstepFunc" ):
+                listener.enterSmoothstepFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSmoothstepFunc" ):
+                listener.exitSmoothstepFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSmoothstepFunc" ):
                 return visitor.visitSmoothstepFunc(self)
@@ -6263,6 +7359,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCauchyFunc" ):
+                listener.enterCauchyFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCauchyFunc" ):
+                listener.exitCauchyFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitCauchyFunc" ):
                 return visitor.visitCauchyFunc(self)
@@ -6294,6 +7398,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLogNormalFunc" ):
+                listener.enterLogNormalFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLogNormalFunc" ):
+                listener.exitLogNormalFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitLogNormalFunc" ):
                 return visitor.visitLogNormalFunc(self)
@@ -6325,6 +7437,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterElasticEaseFunc" ):
+                listener.enterElasticEaseFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitElasticEaseFunc" ):
+                listener.exitElasticEaseFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitElasticEaseFunc" ):
                 return visitor.visitElasticEaseFunc(self)
@@ -6356,6 +7476,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterRangeFunc" ):
+                listener.enterRangeFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitRangeFunc" ):
+                listener.exitRangeFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitRangeFunc" ):
                 return visitor.visitRangeFunc(self)
@@ -6387,6 +7515,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterClampFunc" ):
+                listener.enterClampFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitClampFunc" ):
+                listener.exitClampFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitClampFunc" ):
                 return visitor.visitClampFunc(self)
@@ -6418,6 +7554,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSineEaseFunc" ):
+                listener.enterSineEaseFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSineEaseFunc" ):
+                listener.exitSineEaseFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSineEaseFunc" ):
                 return visitor.visitSineEaseFunc(self)
@@ -6707,6 +7851,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDistFunc" ):
+                listener.enterDistFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDistFunc" ):
+                listener.exitDistFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitDistFunc" ):
                 return visitor.visitDistFunc(self)
@@ -6738,6 +7890,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNvlFunc" ):
+                listener.enterNvlFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNvlFunc" ):
+                listener.exitNvlFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitNvlFunc" ):
                 return visitor.visitNvlFunc(self)
@@ -6769,6 +7929,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSwapFunc" ):
+                listener.enterSwapFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSwapFunc" ):
+                listener.exitSwapFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSwapFunc" ):
                 return visitor.visitSwapFunc(self)
@@ -6910,6 +8078,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterRemapFunc" ):
+                listener.enterRemapFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitRemapFunc" ):
+                listener.exitRemapFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitRemapFunc" ):
                 return visitor.visitRemapFunc(self)
@@ -6999,6 +8175,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSMaxFunc" ):
+                listener.enterSMaxFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSMaxFunc" ):
+                listener.exitSMaxFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSMaxFunc" ):
                 return visitor.visitSMaxFunc(self)
@@ -7030,6 +8214,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterMapFunc" ):
+                listener.enterMapFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitMapFunc" ):
+                listener.exitMapFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitMapFunc" ):
                 return visitor.visitMapFunc(self)
@@ -7061,6 +8253,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterEzConvFunc" ):
+                listener.enterEzConvFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitEzConvFunc" ):
+                listener.exitEzConvFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitEzConvFunc" ):
                 return visitor.visitEzConvFunc(self)
@@ -7089,6 +8289,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPermuteFunc" ):
+                listener.enterPermuteFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPermuteFunc" ):
+                listener.exitPermuteFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitPermuteFunc" ):
                 return visitor.visitPermuteFunc(self)
@@ -7117,6 +8325,14 @@ class MathExprParser ( Parser ):
         def RPAREN(self):
             return self.getToken(MathExprParser.RPAREN, 0)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterReshapeFunc" ):
+                listener.enterReshapeFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitReshapeFunc" ):
+                listener.exitReshapeFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitReshapeFunc" ):
                 return visitor.visitReshapeFunc(self)
@@ -7148,6 +8364,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSMinFunc" ):
+                listener.enterSMinFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSMinFunc" ):
+                listener.exitSMinFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitSMinFunc" ):
                 return visitor.visitSMinFunc(self)
@@ -7179,6 +8403,14 @@ class MathExprParser ( Parser ):
             else:
                 return self.getToken(MathExprParser.COMMA, i)
 
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConvFunc" ):
+                listener.enterConvFunc(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConvFunc" ):
+                listener.exitConvFunc(self)
+
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitConvFunc" ):
                 return visitor.visitConvFunc(self)
diff --git a/more_math/Parser/UnifiedMathVisitor.py b/more_math/Parser/UnifiedMathVisitor.py
index f2fbf29..99255b2 100644
--- a/more_math/Parser/UnifiedMathVisitor.py
+++ b/more_math/Parser/UnifiedMathVisitor.py
@@ -91,6 +91,11 @@ class UnifiedMathVisitor(MathExprVisitor):
         """
         Generic binary operation handler.
         """
+        if self._is_tensor(a) and a.numel() == 1:
+            a = float(a.flatten()[0].item())
+        if self._is_tensor(b) and b.numel() == 1:
+            b = float(b.flatten()[0].item())
+
         # one of them is a list and one is tensor
         if self._is_tensor(a) and self._is_list(b):
              if(a.shape[0]==len(b)):
@@ -121,6 +126,9 @@ class UnifiedMathVisitor(MathExprVisitor):
         return scalar_op(a, b)
 
     def _unary_op(self, a, torch_op, scalar_op):
+        if self._is_tensor(a) and a.numel() == 1:
+            a = float(a.flatten()[0].item())
+
         if self._is_list(a):
             return [self._unary_op(x, torch_op, scalar_op) for x in a]
         if self._is_tensor(a):
@@ -128,7 +136,10 @@ class UnifiedMathVisitor(MathExprVisitor):
         return scalar_op(a)
 
     def _reduction_op(self, val, torch_op, list_op):
+        # If it's a scalar tensor, return Python float to avoid 0-dim tensor propagation
         if self._is_tensor(val):
+            if val.numel() == 1:
+                return float(val.flatten()[0].item())
             return torch_op(val)
         if self._is_list(val):
             return list_op(val)
@@ -592,7 +603,11 @@ class UnifiedMathVisitor(MathExprVisitor):
         return t * t * (3.0 - 2.0 * t)
 
     def visitRangeFunc(self, ctx):
-        return list(torch.arange((yield ctx.expr(0)), (yield ctx.expr(1)), (yield ctx.expr(2))))
+        s = (yield ctx.expr(0))
+        e = (yield ctx.expr(1))
+        st = (yield ctx.expr(2))
+        arr = torch.arange(s, e, st, device=self.device, dtype=torch.float32)
+        return [float(x) for x in arr.tolist()]
 
     def visitSmootherstepFunc(self, ctx):
         x = (yield ctx.expr(0))
@@ -1311,11 +1326,11 @@ class UnifiedMathVisitor(MathExprVisitor):
         return res
 
     def visitVarDefStmt(self, ctx):
-        res = yield ctx.expr()
+        res = yield ctx.varDef()
         return res
 
     def visitBlockStatement(self, ctx):
-        res = yield ctx.expr()
+        res = yield ctx.block()
         return res
 
     def visitBlock(self, ctx):