# Generated from PS.g4 by ANTLR 4.7.2 # encoding: utf-8 from __future__ import print_function from antlr4 import * from io import StringIO import sys def serializedATN(): with StringIO() as buf: buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3") buf.write(u"\u00c4\u0418\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6") buf.write(u"\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4") buf.write(u"\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t") buf.write(u"\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27") buf.write(u"\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4") buf.write(u"\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t") buf.write(u"#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4") buf.write(u",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62") buf.write(u"\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\4") buf.write(u"8\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@") buf.write(u"\3\2\3\2\3\3\3\3\5\3\u0085\n\3\3\4\3\4\3\5\3\5\3\5\3") buf.write(u"\5\3\5\3\5\5\5\u008f\n\5\3\6\3\6\3\6\3\6\5\6\u0095\n") buf.write(u"\6\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3\t\5") buf.write(u"\t\u00a3\n\t\3\n\3\n\3\n\7\n\u00a8\n\n\f\n\16\n\u00ab") buf.write(u"\13\n\3\13\3\13\3\13\3\13\7\13\u00b1\n\13\f\13\16\13") buf.write(u"\u00b4\13\13\3\13\5\13\u00b7\n\13\3\13\3\13\3\13\3\13") buf.write(u"\3\13\3\13\5\13\u00bf\n\13\3\13\3\13\3\13\3\13\5\13\u00c5") buf.write(u"\n\13\3\f\3\f\3\f\3\f\7\f\u00cb\n\f\f\f\16\f\u00ce\13") buf.write(u"\f\3\f\5\f\u00d1\n\f\3\f\3\f\3\r\3\r\3\r\7\r\u00d8\n") buf.write(u"\r\f\r\16\r\u00db\13\r\3\16\3\16\3\16\3\16\3\16\3\16") buf.write(u"\7\16\u00e3\n\16\f\16\16\16\u00e6\13\16\3\17\3\17\3\17") buf.write(u"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3") buf.write(u"\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17") buf.write(u"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3") buf.write(u"\17\3\17\3\17\5\17\u010d\n\17\3\20\3\20\3\20\3\20\3\20") buf.write(u"\7\20\u0114\n\20\f\20\16\20\u0117\13\20\3\20\3\20\3\20") buf.write(u"\3\20\3\20\7\20\u011e\n\20\f\20\16\20\u0121\13\20\5\20") buf.write(u"\u0123\n\20\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3") buf.write(u"\23\3\23\3\23\3\23\7\23\u0131\n\23\f\23\16\23\u0134\13") buf.write(u"\23\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u013c\n\24\f\24") buf.write(u"\16\24\u013f\13\24\3\25\3\25\3\25\3\25\3\25\3\25\7\25") buf.write(u"\u0147\n\25\f\25\16\25\u014a\13\25\3\26\3\26\3\26\6\26") buf.write(u"\u014f\n\26\r\26\16\26\u0150\5\26\u0153\n\26\3\27\3\27") buf.write(u"\3\27\3\27\7\27\u0159\n\27\f\27\16\27\u015c\13\27\5\27") buf.write(u"\u015e\n\27\3\30\3\30\7\30\u0162\n\30\f\30\16\30\u0165") buf.write(u"\13\30\3\31\3\31\7\31\u0169\n\31\f\31\16\31\u016c\13") buf.write(u"\31\3\32\3\32\3\32\5\32\u0171\n\32\3\33\3\33\3\33\3\33") buf.write(u"\3\33\3\33\5\33\u0179\n\33\3\34\3\34\3\34\3\34\5\34\u017f") buf.write(u"\n\34\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u0187\n\35\3") buf.write(u"\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36") buf.write(u"\3\36\5\36\u0195\n\36\3\36\5\36\u0198\n\36\7\36\u019a") buf.write(u"\n\36\f\36\16\36\u019d\13\36\3\37\3\37\3\37\3\37\3\37") buf.write(u"\3\37\3\37\3\37\3\37\3\37\5\37\u01a9\n\37\3\37\5\37\u01ac") buf.write(u"\n\37\7\37\u01ae\n\37\f\37\16\37\u01b1\13\37\3 \3 \3") buf.write(u" \3 \3 \3 \3 \3 \3 \3 \3 \5 \u01be\n \3!\3!\3!\3!\3!") buf.write(u"\3!\3!\3!\3!\3!\5!\u01ca\n!\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") buf.write(u"\"\3\"\5\"\u023c\n\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3") buf.write(u"#\3#\3#\3#\3#\3#\5#\u024e\n#\3$\3$\3$\3$\3$\3$\3$\3$") buf.write(u"\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3") buf.write(u"$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$") buf.write(u"\3$\3$\3$\3$\3$\5$\u0280\n$\3%\3%\3%\3%\3%\3%\3%\3%\3") buf.write(u"%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%") buf.write(u"\3%\3%\3%\3%\3%\3%\5%\u02a2\n%\3&\3&\3&\3&\3&\3&\3&\3") buf.write(u"&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&") buf.write(u"\3&\3&\3&\3&\3&\3&\3&\5&\u02c4\n&\3\'\3\'\3\'\3\'\3\'") buf.write(u"\3(\3(\3(\3(\5(\u02cf\n(\3(\5(\u02d2\n(\3)\3)\3)\3)\5") buf.write(u")\u02d8\n)\3)\3)\3)\3)\3)\3)\3)\3)\5)\u02e2\n)\3*\3*") buf.write(u"\3*\3*\3*\3*\3*\3*\5*\u02ec\n*\3+\3+\3+\3+\3+\3,\6,\u02f4") buf.write(u"\n,\r,\16,\u02f5\3-\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.") buf.write(u"\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u030e\n.\3/\3/\3\60") buf.write(u"\3\60\3\61\3\61\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3") buf.write(u"\63\5\63\u031e\n\63\3\64\3\64\3\64\3\64\3\64\3\64\5\64") buf.write(u"\u0326\n\64\3\65\3\65\5\65\u032a\n\65\3\65\5\65\u032d") buf.write(u"\n\65\3\65\5\65\u0330\n\65\3\65\5\65\u0333\n\65\5\65") buf.write(u"\u0335\n\65\3\65\5\65\u0338\n\65\3\65\3\65\3\65\5\65") buf.write(u"\u033d\n\65\3\65\3\65\3\65\5\65\u0342\n\65\3\65\3\65") buf.write(u"\3\65\5\65\u0347\n\65\3\65\3\65\3\65\5\65\u034c\n\65") buf.write(u"\3\65\3\65\5\65\u0350\n\65\3\65\5\65\u0353\n\65\3\65") buf.write(u"\5\65\u0356\n\65\3\65\5\65\u0359\n\65\5\65\u035b\n\65") buf.write(u"\3\65\5\65\u035e\n\65\3\65\3\65\3\65\5\65\u0363\n\65") buf.write(u"\3\65\3\65\3\65\5\65\u0368\n\65\3\65\3\65\3\65\5\65\u036d") buf.write(u"\n\65\3\65\3\65\3\65\5\65\u0372\n\65\3\65\3\65\5\65\u0376") buf.write(u"\n\65\3\65\5\65\u0379\n\65\3\65\3\65\3\65\3\65\5\65\u037f") buf.write(u"\n\65\3\65\3\65\5\65\u0383\n\65\3\65\3\65\5\65\u0387") buf.write(u"\n\65\3\65\3\65\3\65\3\65\5\65\u038d\n\65\3\65\3\65\3") buf.write(u"\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65") buf.write(u"\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5") buf.write(u"\65\u03a6\n\65\3\65\5\65\u03a9\n\65\3\65\3\65\3\65\5") buf.write(u"\65\u03ae\n\65\3\65\3\65\3\65\3\65\3\65\5\65\u03b5\n") buf.write(u"\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65") buf.write(u"\3\65\5\65\u03c2\n\65\3\65\3\65\3\65\3\65\3\65\3\65\3") buf.write(u"\65\3\65\5\65\u03cc\n\65\5\65\u03ce\n\65\3\66\3\66\3") buf.write(u"\66\3\66\3\66\5\66\u03d5\n\66\3\67\3\67\3\67\3\67\3\67") buf.write(u"\3\67\3\67\3\67\5\67\u03df\n\67\38\38\38\38\38\38\38") buf.write(u"\38\38\58\u03ea\n8\38\38\39\39\3:\3:\3;\3;\3;\3;\3;\5") buf.write(u";\u03f7\n;\3<\3<\3=\3=\3=\3=\3=\5=\u0400\n=\3=\3=\5=") buf.write(u"\u0404\n=\3>\3>\3>\3>\3>\3>\5>\u040c\n>\3?\3?\3?\3?\3") buf.write(u"?\3@\3@\3@\3@\3@\3@\2\b\32$&(:@BDFHJLNP") buf.write(u"RTVXZ\\^`bdfhjlnprtvxz|~\2\21\4\2\3*\u009c\u009c\3\2") buf.write(u"+.\3\2\u00b7\u00be\3\2\u00b8\u00b9\3\2\61\62\6\2\63\64") buf.write(u"\u0095\u0097\u009b\u009b\u00ab\u00ab\3\2\u00b0\u00b2") buf.write(u"\5\2Yp~\177\u0082\u0082\4\2|}\u0080\u0081\b\2qvyz\u0083") buf.write(u"\u0083\u0086\u0087\u0089\u008c\u0090\u0094\6\2wx\u0084") buf.write(u"\u0085\u0088\u0088\u008d\u008f\4\2\65\65??\4\2\66\66") buf.write(u"@@\3\2WX\4\2\u00b2\u00b2\u00c1\u00c2\2\u048e\2\u0080") buf.write(u"\3\2\2\2\4\u0084\3\2\2\2\6\u0086\3\2\2\2\b\u0088\3\2") buf.write(u"\2\2\n\u0094\3\2\2\2\f\u0098\3\2\2\2\16\u009c\3\2\2\2") buf.write(u"\20\u00a2\3\2\2\2\22\u00a4\3\2\2\2\24\u00ac\3\2\2\2\26") buf.write(u"\u00c6\3\2\2\2\30\u00d4\3\2\2\2\32\u00dc\3\2\2\2\34\u010c") buf.write(u"\3\2\2\2\36\u0122\3\2\2\2 \u0124\3\2\2\2\"\u0128\3\2") buf.write(u"\2\2$\u012a\3\2\2\2&\u0135\3\2\2\2(\u0140\3\2\2\2*\u0152") buf.write(u"\3\2\2\2,\u015d\3\2\2\2.\u015f\3\2\2\2\60\u0166\3\2\2") buf.write(u"\2\62\u0170\3\2\2\2\64\u0172\3\2\2\2\66\u017a\3\2\2\2") buf.write(u"8\u0182\3\2\2\2:\u018a\3\2\2\2<\u019e\3\2\2\2>\u01bd") buf.write(u"\3\2\2\2@\u01c9\3\2\2\2B\u023b\3\2\2\2D\u024d\3\2\2\2") buf.write(u"F\u027f\3\2\2\2H\u02a1\3\2\2\2J\u02c3\3\2\2\2L\u02c5") buf.write(u"\3\2\2\2N\u02ce\3\2\2\2P\u02d7\3\2\2\2R\u02eb\3\2\2\2") buf.write(u"T\u02ed\3\2\2\2V\u02f3\3\2\2\2X\u02f7\3\2\2\2Z\u030d") buf.write(u"\3\2\2\2\\\u030f\3\2\2\2^\u0311\3\2\2\2`\u0313\3\2\2") buf.write(u"\2b\u0315\3\2\2\2d\u031d\3\2\2\2f\u0325\3\2\2\2h\u03cd") buf.write(u"\3\2\2\2j\u03d4\3\2\2\2l\u03de\3\2\2\2n\u03e0\3\2\2\2") buf.write(u"p\u03ed\3\2\2\2r\u03ef\3\2\2\2t\u03f6\3\2\2\2v\u03f8") buf.write(u"\3\2\2\2x\u03fa\3\2\2\2z\u0405\3\2\2\2|\u040d\3\2\2\2") buf.write(u"~\u0412\3\2\2\2\u0080\u0081\t\2\2\2\u0081\3\3\2\2\2\u0082") buf.write(u"\u0085\5\32\16\2\u0083\u0085\5\34\17\2\u0084\u0082\3") buf.write(u"\2\2\2\u0084\u0083\3\2\2\2\u0085\5\3\2\2\2\u0086\u0087") buf.write(u"\t\3\2\2\u0087\7\3\2\2\2\u0088\u0089\7\u00b2\2\2\u0089") buf.write(u"\u008e\7\u00a9\2\2\u008a\u008f\7\u00b5\2\2\u008b\u008c") buf.write(u"\79\2\2\u008c\u008d\7\u00b5\2\2\u008d\u008f\7:\2\2\u008e") buf.write(u"\u008a\3\2\2\2\u008e\u008b\3\2\2\2\u008f\t\3\2\2\2\u0090") buf.write(u"\u0095\5\"\22\2\u0091\u0095\5B\"\2\u0092\u0095\7\61\2") buf.write(u"\2\u0093\u0095\7\62\2\2\u0094\u0090\3\2\2\2\u0094\u0091") buf.write(u"\3\2\2\2\u0094\u0092\3\2\2\2\u0094\u0093\3\2\2\2\u0095") buf.write(u"\u0096\3\2\2\2\u0096\u0097\5\b\5\2\u0097\13\3\2\2\2\u0098") buf.write(u"\u0099\5\b\5\2\u0099\u009a\7\u00b4\2\2\u009a\u009b\5") buf.write(u"\b\5\2\u009b\r\3\2\2\2\u009c\u009d\5\b\5\2\u009d\u009e") buf.write(u"\5\n\6\2\u009e\17\3\2\2\2\u009f\u00a3\5\16\b\2\u00a0") buf.write(u"\u00a3\5\n\6\2\u00a1\u00a3\5\f\7\2\u00a2\u009f\3\2\2") buf.write(u"\2\u00a2\u00a0\3\2\2\2\u00a2\u00a1\3\2\2\2\u00a3\21\3") buf.write(u"\2\2\2\u00a4\u00a9\5\20\t\2\u00a5\u00a6\7\u00ad\2\2\u00a6") buf.write(u"\u00a8\5\20\t\2\u00a7\u00a5\3\2\2\2\u00a8\u00ab\3\2\2") buf.write(u"\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\23\3") buf.write(u"\2\2\2\u00ab\u00a9\3\2\2\2\u00ac\u00ad\7\u00a3\2\2\u00ad") buf.write(u"\u00b2\5\30\r\2\u00ae\u00af\7\u00a8\2\2\u00af\u00b1\5") buf.write(u"\30\r\2\u00b0\u00ae\3\2\2\2\u00b1\u00b4\3\2\2\2\u00b2") buf.write(u"\u00b0\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00b6\3\2\2") buf.write(u"\2\u00b4\u00b2\3\2\2\2\u00b5\u00b7\7\u00a8\2\2\u00b6") buf.write(u"\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\3\2\2") buf.write(u"\2\u00b8\u00c4\7\u00a4\2\2\u00b9\u00be\7\u00b3\2\2\u00ba") buf.write(u"\u00bb\7?\2\2\u00bb\u00bc\5\22\n\2\u00bc\u00bd\7@\2\2") buf.write(u"\u00bd\u00bf\3\2\2\2\u00be\u00ba\3\2\2\2\u00be\u00bf") buf.write(u"\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c1\79\2\2\u00c1") buf.write(u"\u00c2\5\22\n\2\u00c2\u00c3\7:\2\2\u00c3\u00c5\3\2\2") buf.write(u"\2\u00c4\u00b9\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\25\3") buf.write(u"\2\2\2\u00c6\u00c7\7\u00a5\2\2\u00c7\u00cc\5\30\r\2\u00c8") buf.write(u"\u00c9\7\u00a8\2\2\u00c9\u00cb\5\30\r\2\u00ca\u00c8\3") buf.write(u"\2\2\2\u00cb\u00ce\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cc") buf.write(u"\u00cd\3\2\2\2\u00cd\u00d0\3\2\2\2\u00ce\u00cc\3\2\2") buf.write(u"\2\u00cf\u00d1\7\u00a8\2\2\u00d0\u00cf\3\2\2\2\u00d0") buf.write(u"\u00d1\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3\7\u00a6") buf.write(u"\2\2\u00d3\27\3\2\2\2\u00d4\u00d9\5\"\22\2\u00d5\u00d6") buf.write(u"\7\u00a7\2\2\u00d6\u00d8\5\"\22\2\u00d7\u00d5\3\2\2\2") buf.write(u"\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da") buf.write(u"\3\2\2\2\u00da\31\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd") buf.write(u"\b\16\1\2\u00dd\u00de\5\"\22\2\u00de\u00e4\3\2\2\2\u00df") buf.write(u"\u00e0\f\4\2\2\u00e0\u00e1\t\4\2\2\u00e1\u00e3\5\32\16") buf.write(u"\5\u00e2\u00df\3\2\2\2\u00e3\u00e6\3\2\2\2\u00e4\u00e2") buf.write(u"\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\33\3\2\2\2\u00e6\u00e4") buf.write(u"\3\2\2\2\u00e7\u010d\5\36\20\2\u00e8\u00e9\7?\2\2\u00e9") buf.write(u"\u00ea\5\36\20\2\u00ea\u00eb\7@\2\2\u00eb\u010d\3\2\2") buf.write(u"\2\u00ec\u00ed\79\2\2\u00ed\u00ee\5\36\20\2\u00ee\u00ef") buf.write(u"\7:\2\2\u00ef\u010d\3\2\2\2\u00f0\u00f1\7;\2\2\u00f1") buf.write(u"\u00f2\5\36\20\2\u00f2\u00f3\7<\2\2\u00f3\u010d\3\2\2") buf.write(u"\2\u00f4\u00f5\7P\2\2\u00f5\u00f6\7?\2\2\u00f6\u00f7") buf.write(u"\5\36\20\2\u00f7\u00f8\7Q\2\2\u00f8\u00f9\7@\2\2\u00f9") buf.write(u"\u010d\3\2\2\2\u00fa\u00fb\7P\2\2\u00fb\u00fc\7;\2\2") buf.write(u"\u00fc\u00fd\5\36\20\2\u00fd\u00fe\7Q\2\2\u00fe\u00ff") buf.write(u"\7<\2\2\u00ff\u010d\3\2\2\2\u0100\u0101\7R\2\2\u0101") buf.write(u"\u0102\7?\2\2\u0102\u0103\5\36\20\2\u0103\u0104\7S\2") buf.write(u"\2\u0104\u0105\7@\2\2\u0105\u010d\3\2\2\2\u0106\u0107") buf.write(u"\7R\2\2\u0107\u0108\7;\2\2\u0108\u0109\5\36\20\2\u0109") buf.write(u"\u010a\7S\2\2\u010a\u010b\7<\2\2\u010b\u010d\3\2\2\2") buf.write(u"\u010c\u00e7\3\2\2\2\u010c\u00e8\3\2\2\2\u010c\u00ec") buf.write(u"\3\2\2\2\u010c\u00f0\3\2\2\2\u010c\u00f4\3\2\2\2\u010c") buf.write(u"\u00fa\3\2\2\2\u010c\u0100\3\2\2\2\u010c\u0106\3\2\2") buf.write(u"\2\u010d\35\3\2\2\2\u010e\u010f\5\32\16\2\u010f\u0110") buf.write(u"\7\u00ad\2\2\u0110\u0115\5\32\16\2\u0111\u0112\7\u00ad") buf.write(u"\2\2\u0112\u0114\5\32\16\2\u0113\u0111\3\2\2\2\u0114") buf.write(u"\u0117\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0116\3\2\2") buf.write(u"\2\u0116\u0123\3\2\2\2\u0117\u0115\3\2\2\2\u0118\u0119") buf.write(u"\5\32\16\2\u0119\u011a\7\u00ac\2\2\u011a\u011f\5\32\16") buf.write(u"\2\u011b\u011c\7\u00ac\2\2\u011c\u011e\5\32\16\2\u011d") buf.write(u"\u011b\3\2\2\2\u011e\u0121\3\2\2\2\u011f\u011d\3\2\2") buf.write(u"\2\u011f\u0120\3\2\2\2\u0120\u0123\3\2\2\2\u0121\u011f") buf.write(u"\3\2\2\2\u0122\u010e\3\2\2\2\u0122\u0118\3\2\2\2\u0123") buf.write(u"\37\3\2\2\2\u0124\u0125\5\"\22\2\u0125\u0126\t\5\2\2") buf.write(u"\u0126\u0127\5\"\22\2\u0127!\3\2\2\2\u0128\u0129\5$\23") buf.write(u"\2\u0129#\3\2\2\2\u012a\u012b\b\23\1\2\u012b\u012c\5") buf.write(u"&\24\2\u012c\u0132\3\2\2\2\u012d\u012e\f\4\2\2\u012e") buf.write(u"\u012f\t\6\2\2\u012f\u0131\5$\23\5\u0130\u012d\3\2\2") buf.write(u"\2\u0131\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133") buf.write(u"\3\2\2\2\u0133%\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u0136") buf.write(u"\b\24\1\2\u0136\u0137\5*\26\2\u0137\u013d\3\2\2\2\u0138") buf.write(u"\u0139\f\4\2\2\u0139\u013a\t\7\2\2\u013a\u013c\5&\24") buf.write(u"\5\u013b\u0138\3\2\2\2\u013c\u013f\3\2\2\2\u013d\u013b") buf.write(u"\3\2\2\2\u013d\u013e\3\2\2\2\u013e\'\3\2\2\2\u013f\u013d") buf.write(u"\3\2\2\2\u0140\u0141\b\25\1\2\u0141\u0142\5,\27\2\u0142") buf.write(u"\u0148\3\2\2\2\u0143\u0144\f\4\2\2\u0144\u0145\t\7\2") buf.write(u"\2\u0145\u0147\5(\25\5\u0146\u0143\3\2\2\2\u0147\u014a") buf.write(u"\3\2\2\2\u0148\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149") buf.write(u")\3\2\2\2\u014a\u0148\3\2\2\2\u014b\u014c\t\6\2\2\u014c") buf.write(u"\u0153\5*\26\2\u014d\u014f\5.\30\2\u014e\u014d\3\2\2") buf.write(u"\2\u014f\u0150\3\2\2\2\u0150\u014e\3\2\2\2\u0150\u0151") buf.write(u"\3\2\2\2\u0151\u0153\3\2\2\2\u0152\u014b\3\2\2\2\u0152") buf.write(u"\u014e\3\2\2\2\u0153+\3\2\2\2\u0154\u0155\t\6\2\2\u0155") buf.write(u"\u015e\5,\27\2\u0156\u015a\5.\30\2\u0157\u0159\5\60\31") buf.write(u"\2\u0158\u0157\3\2\2\2\u0159\u015c\3\2\2\2\u015a\u0158") buf.write(u"\3\2\2\2\u015a\u015b\3\2\2\2\u015b\u015e\3\2\2\2\u015c") buf.write(u"\u015a\3\2\2\2\u015d\u0154\3\2\2\2\u015d\u0156\3\2\2") buf.write(u"\2\u015e-\3\2\2\2\u015f\u0163\5:\36\2\u0160\u0162\5\62") buf.write(u"\32\2\u0161\u0160\3\2\2\2\u0162\u0165\3\2\2\2\u0163\u0161") buf.write(u"\3\2\2\2\u0163\u0164\3\2\2\2\u0164/\3\2\2\2\u0165\u0163") buf.write(u"\3\2\2\2\u0166\u016a\5<\37\2\u0167\u0169\5\62\32\2\u0168") buf.write(u"\u0167\3\2\2\2\u0169\u016c\3\2\2\2\u016a\u0168\3\2\2") buf.write(u"\2\u016a\u016b\3\2\2\2\u016b\61\3\2\2\2\u016c\u016a\3") buf.write(u"\2\2\2\u016d\u0171\7\u00bf\2\2\u016e\u0171\5\64\33\2") buf.write(u"\u016f\u0171\5\6\4\2\u0170\u016d\3\2\2\2\u0170\u016e") buf.write(u"\3\2\2\2\u0170\u016f\3\2\2\2\u0171\63\3\2\2\2\u0172\u0178") buf.write(u"\7C\2\2\u0173\u0179\58\35\2\u0174\u0179\5\66\34\2\u0175") buf.write(u"\u0176\58\35\2\u0176\u0177\5\66\34\2\u0177\u0179\3\2") buf.write(u"\2\2\u0178\u0173\3\2\2\2\u0178\u0174\3\2\2\2\u0178\u0175") buf.write(u"\3\2\2\2\u0179\65\3\2\2\2\u017a\u017b\7\u00a9\2\2\u017b") buf.write(u"\u017e\79\2\2\u017c\u017f\5\"\22\2\u017d\u017f\5 \21") buf.write(u"\2\u017e\u017c\3\2\2\2\u017e\u017d\3\2\2\2\u017f\u0180") buf.write(u"\3\2\2\2\u0180\u0181\7:\2\2\u0181\67\3\2\2\2\u0182\u0183") buf.write(u"\7\u00aa\2\2\u0183\u0186\79\2\2\u0184\u0187\5\"\22\2") buf.write(u"\u0185\u0187\5 \21\2\u0186\u0184\3\2\2\2\u0186\u0185") buf.write(u"\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\7:\2\2\u0189") buf.write(u"9\3\2\2\2\u018a\u018b\b\36\1\2\u018b\u018c\5> \2\u018c") buf.write(u"\u019b\3\2\2\2\u018d\u018e\f\4\2\2\u018e\u0194\7\u00aa") buf.write(u"\2\2\u018f\u0195\5R*\2\u0190\u0191\79\2\2\u0191\u0192") buf.write(u"\5\"\22\2\u0192\u0193\7:\2\2\u0193\u0195\3\2\2\2\u0194") buf.write(u"\u018f\3\2\2\2\u0194\u0190\3\2\2\2\u0195\u0197\3\2\2") buf.write(u"\2\u0196\u0198\5x=\2\u0197\u0196\3\2\2\2\u0197\u0198") buf.write(u"\3\2\2\2\u0198\u019a\3\2\2\2\u0199\u018d\3\2\2\2\u019a") buf.write(u"\u019d\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2") buf.write(u"\2\u019c;\3\2\2\2\u019d\u019b\3\2\2\2\u019e\u019f\b\37") buf.write(u"\1\2\u019f\u01a0\5@!\2\u01a0\u01af\3\2\2\2\u01a1\u01a2") buf.write(u"\f\4\2\2\u01a2\u01a8\7\u00aa\2\2\u01a3\u01a9\5R*\2\u01a4") buf.write(u"\u01a5\79\2\2\u01a5\u01a6\5\"\22\2\u01a6\u01a7\7:\2\2") buf.write(u"\u01a7\u01a9\3\2\2\2\u01a8\u01a3\3\2\2\2\u01a8\u01a4") buf.write(u"\3\2\2\2\u01a9\u01ab\3\2\2\2\u01aa\u01ac\5x=\2\u01ab") buf.write(u"\u01aa\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ae\3\2\2") buf.write(u"\2\u01ad\u01a1\3\2\2\2\u01ae\u01b1\3\2\2\2\u01af\u01ad") buf.write(u"\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0=\3\2\2\2\u01b1\u01af") buf.write(u"\3\2\2\2\u01b2\u01be\5B\"\2\u01b3\u01be\5D#\2\u01b4\u01be") buf.write(u"\5F$\2\u01b5\u01be\5H%\2\u01b6\u01be\5J&\2\u01b7\u01be") buf.write(u"\5h\65\2\u01b8\u01be\5R*\2\u01b9\u01be\5X-\2\u01ba\u01be") buf.write(u"\5Z.\2\u01bb\u01be\5\24\13\2\u01bc\u01be\5\26\f\2\u01bd") buf.write(u"\u01b2\3\2\2\2\u01bd\u01b3\3\2\2\2\u01bd\u01b4\3\2\2") buf.write(u"\2\u01bd\u01b5\3\2\2\2\u01bd\u01b6\3\2\2\2\u01bd\u01b7") buf.write(u"\3\2\2\2\u01bd\u01b8\3\2\2\2\u01bd\u01b9\3\2\2\2\u01bd") buf.write(u"\u01ba\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2") buf.write(u"\2\u01be?\3\2\2\2\u01bf\u01ca\5B\"\2\u01c0\u01ca\5D#") buf.write(u"\2\u01c1\u01ca\5F$\2\u01c2\u01ca\5H%\2\u01c3\u01ca\5") buf.write(u"J&\2\u01c4\u01ca\5R*\2\u01c5\u01ca\5X-\2\u01c6\u01ca") buf.write(u"\5Z.\2\u01c7\u01ca\5\24\13\2\u01c8\u01ca\5\26\f\2\u01c9") buf.write(u"\u01bf\3\2\2\2\u01c9\u01c0\3\2\2\2\u01c9\u01c1\3\2\2") buf.write(u"\2\u01c9\u01c2\3\2\2\2\u01c9\u01c3\3\2\2\2\u01c9\u01c4") buf.write(u"\3\2\2\2\u01c9\u01c5\3\2\2\2\u01c9\u01c6\3\2\2\2\u01c9") buf.write(u"\u01c7\3\2\2\2\u01c9\u01c8\3\2\2\2\u01caA\3\2\2\2\u01cb") buf.write(u"\u01cc\7\65\2\2\u01cc\u01cd\5\"\22\2\u01cd\u01ce\7\66") buf.write(u"\2\2\u01ce\u023c\3\2\2\2\u01cf\u01d0\7\67\2\2\u01d0\u01d1") buf.write(u"\5\"\22\2\u01d1\u01d2\78\2\2\u01d2\u023c\3\2\2\2\u01d3") buf.write(u"\u01d4\79\2\2\u01d4\u01d5\5\"\22\2\u01d5\u01d6\7:\2\2") buf.write(u"\u01d6\u023c\3\2\2\2\u01d7\u01d8\7;\2\2\u01d8\u01d9\5") buf.write(u"\"\22\2\u01d9\u01da\7<\2\2\u01da\u023c\3\2\2\2\u01db") buf.write(u"\u01dc\7=\2\2\u01dc\u01dd\5\"\22\2\u01dd\u01de\7>\2\2") buf.write(u"\u01de\u023c\3\2\2\2\u01df\u01e0\7?\2\2\u01e0\u01e1\5") buf.write(u"\"\22\2\u01e1\u01e2\7@\2\2\u01e2\u023c\3\2\2\2\u01e3") buf.write(u"\u01e4\7A\2\2\u01e4\u01e5\5\"\22\2\u01e5\u01e6\7B\2\2") buf.write(u"\u01e6\u023c\3\2\2\2\u01e7\u01e8\7P\2\2\u01e8\u01e9\7") buf.write(u"\65\2\2\u01e9\u01ea\5\"\22\2\u01ea\u01eb\7Q\2\2\u01eb") buf.write(u"\u01ec\7\66\2\2\u01ec\u023c\3\2\2\2\u01ed\u01ee\7P\2") buf.write(u"\2\u01ee\u01ef\7\67\2\2\u01ef\u01f0\5\"\22\2\u01f0\u01f1") buf.write(u"\7Q\2\2\u01f1\u01f2\78\2\2\u01f2\u023c\3\2\2\2\u01f3") buf.write(u"\u01f4\7P\2\2\u01f4\u01f5\79\2\2\u01f5\u01f6\5\"\22\2") buf.write(u"\u01f6\u01f7\7Q\2\2\u01f7\u01f8\7:\2\2\u01f8\u023c\3") buf.write(u"\2\2\2\u01f9\u01fa\7P\2\2\u01fa\u01fb\7;\2\2\u01fb\u01fc") buf.write(u"\5\"\22\2\u01fc\u01fd\7Q\2\2\u01fd\u01fe\7<\2\2\u01fe") buf.write(u"\u023c\3\2\2\2\u01ff\u0200\7P\2\2\u0200\u0201\7=\2\2") buf.write(u"\u0201\u0202\5\"\22\2\u0202\u0203\7Q\2\2\u0203\u0204") buf.write(u"\7>\2\2\u0204\u023c\3\2\2\2\u0205\u0206\7P\2\2\u0206") buf.write(u"\u0207\7?\2\2\u0207\u0208\5\"\22\2\u0208\u0209\7Q\2\2") buf.write(u"\u0209\u020a\7@\2\2\u020a\u023c\3\2\2\2\u020b\u020c\7") buf.write(u"P\2\2\u020c\u020d\7A\2\2\u020d\u020e\5\"\22\2\u020e\u020f") buf.write(u"\7Q\2\2\u020f\u0210\7B\2\2\u0210\u023c\3\2\2\2\u0211") buf.write(u"\u0212\7R\2\2\u0212\u0213\7\65\2\2\u0213\u0214\5\"\22") buf.write(u"\2\u0214\u0215\7S\2\2\u0215\u0216\7\66\2\2\u0216\u023c") buf.write(u"\3\2\2\2\u0217\u0218\7R\2\2\u0218\u0219\7\67\2\2\u0219") buf.write(u"\u021a\5\"\22\2\u021a\u021b\7S\2\2\u021b\u021c\78\2\2") buf.write(u"\u021c\u023c\3\2\2\2\u021d\u021e\7R\2\2\u021e\u021f\7") buf.write(u"9\2\2\u021f\u0220\5\"\22\2\u0220\u0221\7S\2\2\u0221\u0222") buf.write(u"\7:\2\2\u0222\u023c\3\2\2\2\u0223\u0224\7R\2\2\u0224") buf.write(u"\u0225\7;\2\2\u0225\u0226\5\"\22\2\u0226\u0227\7S\2\2") buf.write(u"\u0227\u0228\7<\2\2\u0228\u023c\3\2\2\2\u0229\u022a\7") buf.write(u"R\2\2\u022a\u022b\7=\2\2\u022b\u022c\5\"\22\2\u022c\u022d") buf.write(u"\7S\2\2\u022d\u022e\7>\2\2\u022e\u023c\3\2\2\2\u022f") buf.write(u"\u0230\7R\2\2\u0230\u0231\7?\2\2\u0231\u0232\5\"\22\2") buf.write(u"\u0232\u0233\7S\2\2\u0233\u0234\7@\2\2\u0234\u023c\3") buf.write(u"\2\2\2\u0235\u0236\7R\2\2\u0236\u0237\7A\2\2\u0237\u0238") buf.write(u"\5\"\22\2\u0238\u0239\7S\2\2\u0239\u023a\7B\2\2\u023a") buf.write(u"\u023c\3\2\2\2\u023b\u01cb\3\2\2\2\u023b\u01cf\3\2\2") buf.write(u"\2\u023b\u01d3\3\2\2\2\u023b\u01d7\3\2\2\2\u023b\u01db") buf.write(u"\3\2\2\2\u023b\u01df\3\2\2\2\u023b\u01e3\3\2\2\2\u023b") buf.write(u"\u01e7\3\2\2\2\u023b\u01ed\3\2\2\2\u023b\u01f3\3\2\2") buf.write(u"\2\u023b\u01f9\3\2\2\2\u023b\u01ff\3\2\2\2\u023b\u0205") buf.write(u"\3\2\2\2\u023b\u020b\3\2\2\2\u023b\u0211\3\2\2\2\u023b") buf.write(u"\u0217\3\2\2\2\u023b\u021d\3\2\2\2\u023b\u0223\3\2\2") buf.write(u"\2\u023b\u0229\3\2\2\2\u023b\u022f\3\2\2\2\u023b\u0235") buf.write(u"\3\2\2\2\u023cC\3\2\2\2\u023d\u023e\7G\2\2\u023e\u023f") buf.write(u"\5\"\22\2\u023f\u0240\7G\2\2\u0240\u024e\3\2\2\2\u0241") buf.write(u"\u0242\7P\2\2\u0242\u0243\7G\2\2\u0243\u0244\5\"\22\2") buf.write(u"\u0244\u0245\7Q\2\2\u0245\u0246\7G\2\2\u0246\u024e\3") buf.write(u"\2\2\2\u0247\u0248\7R\2\2\u0248\u0249\7G\2\2\u0249\u024a") buf.write(u"\5\"\22\2\u024a\u024b\7S\2\2\u024b\u024c\7G\2\2\u024c") buf.write(u"\u024e\3\2\2\2\u024d\u023d\3\2\2\2\u024d\u0241\3\2\2") buf.write(u"\2\u024d\u0247\3\2\2\2\u024eE\3\2\2\2\u024f\u0250\7C") buf.write(u"\2\2\u0250\u0251\5\"\22\2\u0251\u0252\7C\2\2\u0252\u0280") buf.write(u"\3\2\2\2\u0253\u0254\7D\2\2\u0254\u0255\5\"\22\2\u0255") buf.write(u"\u0256\7E\2\2\u0256\u0280\3\2\2\2\u0257\u0258\7F\2\2") buf.write(u"\u0258\u0259\5\"\22\2\u0259\u025a\7F\2\2\u025a\u0280") buf.write(u"\3\2\2\2\u025b\u025c\7P\2\2\u025c\u025d\7C\2\2\u025d") buf.write(u"\u025e\5\"\22\2\u025e\u025f\7Q\2\2\u025f\u0260\7C\2\2") buf.write(u"\u0260\u0280\3\2\2\2\u0261\u0262\7P\2\2\u0262\u0263\7") buf.write(u"D\2\2\u0263\u0264\5\"\22\2\u0264\u0265\7Q\2\2\u0265\u0266") buf.write(u"\7E\2\2\u0266\u0280\3\2\2\2\u0267\u0268\7P\2\2\u0268") buf.write(u"\u0269\7F\2\2\u0269\u026a\5\"\22\2\u026a\u026b\7Q\2\2") buf.write(u"\u026b\u026c\7F\2\2\u026c\u0280\3\2\2\2\u026d\u026e\7") buf.write(u"R\2\2\u026e\u026f\7C\2\2\u026f\u0270\5\"\22\2\u0270\u0271") buf.write(u"\7S\2\2\u0271\u0272\7C\2\2\u0272\u0280\3\2\2\2\u0273") buf.write(u"\u0274\7R\2\2\u0274\u0275\7D\2\2\u0275\u0276\5\"\22\2") buf.write(u"\u0276\u0277\7S\2\2\u0277\u0278\7E\2\2\u0278\u0280\3") buf.write(u"\2\2\2\u0279\u027a\7R\2\2\u027a\u027b\7F\2\2\u027b\u027c") buf.write(u"\5\"\22\2\u027c\u027d\7S\2\2\u027d\u027e\7F\2\2\u027e") buf.write(u"\u0280\3\2\2\2\u027f\u024f\3\2\2\2\u027f\u0253\3\2\2") buf.write(u"\2\u027f\u0257\3\2\2\2\u027f\u025b\3\2\2\2\u027f\u0261") buf.write(u"\3\2\2\2\u027f\u0267\3\2\2\2\u027f\u026d\3\2\2\2\u027f") buf.write(u"\u0273\3\2\2\2\u027f\u0279\3\2\2\2\u0280G\3\2\2\2\u0281") buf.write(u"\u0282\7H\2\2\u0282\u0283\5\"\22\2\u0283\u0284\7I\2\2") buf.write(u"\u0284\u02a2\3\2\2\2\u0285\u0286\7J\2\2\u0286\u0287\5") buf.write(u"\"\22\2\u0287\u0288\7K\2\2\u0288\u02a2\3\2\2\2\u0289") buf.write(u"\u028a\7P\2\2\u028a\u028b\7H\2\2\u028b\u028c\5\"\22\2") buf.write(u"\u028c\u028d\7Q\2\2\u028d\u028e\7I\2\2\u028e\u02a2\3") buf.write(u"\2\2\2\u028f\u0290\7P\2\2\u0290\u0291\7J\2\2\u0291\u0292") buf.write(u"\5\"\22\2\u0292\u0293\7Q\2\2\u0293\u0294\7K\2\2\u0294") buf.write(u"\u02a2\3\2\2\2\u0295\u0296\7R\2\2\u0296\u0297\7H\2\2") buf.write(u"\u0297\u0298\5\"\22\2\u0298\u0299\7S\2\2\u0299\u029a") buf.write(u"\7I\2\2\u029a\u02a2\3\2\2\2\u029b\u029c\7R\2\2\u029c") buf.write(u"\u029d\7J\2\2\u029d\u029e\5\"\22\2\u029e\u029f\7S\2\2") buf.write(u"\u029f\u02a0\7K\2\2\u02a0\u02a2\3\2\2\2\u02a1\u0281\3") buf.write(u"\2\2\2\u02a1\u0285\3\2\2\2\u02a1\u0289\3\2\2\2\u02a1") buf.write(u"\u028f\3\2\2\2\u02a1\u0295\3\2\2\2\u02a1\u029b\3\2\2") buf.write(u"\2\u02a2I\3\2\2\2\u02a3\u02a4\7L\2\2\u02a4\u02a5\5\"") buf.write(u"\22\2\u02a5\u02a6\7M\2\2\u02a6\u02c4\3\2\2\2\u02a7\u02a8") buf.write(u"\7N\2\2\u02a8\u02a9\5\"\22\2\u02a9\u02aa\7O\2\2\u02aa") buf.write(u"\u02c4\3\2\2\2\u02ab\u02ac\7P\2\2\u02ac\u02ad\7L\2\2") buf.write(u"\u02ad\u02ae\5\"\22\2\u02ae\u02af\7Q\2\2\u02af\u02b0") buf.write(u"\7M\2\2\u02b0\u02c4\3\2\2\2\u02b1\u02b2\7P\2\2\u02b2") buf.write(u"\u02b3\7N\2\2\u02b3\u02b4\5\"\22\2\u02b4\u02b5\7Q\2\2") buf.write(u"\u02b5\u02b6\7O\2\2\u02b6\u02c4\3\2\2\2\u02b7\u02b8\7") buf.write(u"R\2\2\u02b8\u02b9\7L\2\2\u02b9\u02ba\5\"\22\2\u02ba\u02bb") buf.write(u"\7S\2\2\u02bb\u02bc\7M\2\2\u02bc\u02c4\3\2\2\2\u02bd") buf.write(u"\u02be\7R\2\2\u02be\u02bf\7N\2\2\u02bf\u02c0\5\"\22\2") buf.write(u"\u02c0\u02c1\7S\2\2\u02c1\u02c2\7O\2\2\u02c2\u02c4\3") buf.write(u"\2\2\2\u02c3\u02a3\3\2\2\2\u02c3\u02a7\3\2\2\2\u02c3") buf.write(u"\u02ab\3\2\2\2\u02c3\u02b1\3\2\2\2\u02c3\u02b7\3\2\2") buf.write(u"\2\u02c3\u02bd\3\2\2\2\u02c4K\3\2\2\2\u02c5\u02c6\5\2") buf.write(u"\2\2\u02c6\u02c7\79\2\2\u02c7\u02c8\5\"\22\2\u02c8\u02c9") buf.write(u"\7:\2\2\u02c9M\3\2\2\2\u02ca\u02cf\7\u00b2\2\2\u02cb") buf.write(u"\u02cf\7\u00c1\2\2\u02cc\u02cf\7\u00c2\2\2\u02cd\u02cf") buf.write(u"\5L\'\2\u02ce\u02ca\3\2\2\2\u02ce\u02cb\3\2\2\2\u02ce") buf.write(u"\u02cc\3\2\2\2\u02ce\u02cd\3\2\2\2\u02cf\u02d1\3\2\2") buf.write(u"\2\u02d0\u02d2\5x=\2\u02d1\u02d0\3\2\2\2\u02d1\u02d2") buf.write(u"\3\2\2\2\u02d2O\3\2\2\2\u02d3\u02d8\7\u00b2\2\2\u02d4") buf.write(u"\u02d8\7\u00c1\2\2\u02d5\u02d8\7\u00c2\2\2\u02d6\u02d8") buf.write(u"\5L\'\2\u02d7\u02d3\3\2\2\2\u02d7\u02d4\3\2\2\2\u02d7") buf.write(u"\u02d5\3\2\2\2\u02d7\u02d6\3\2\2\2\u02d8\u02e1\3\2\2") buf.write(u"\2\u02d9\u02da\5z>\2\u02da\u02db\5x=\2\u02db\u02e2\3") buf.write(u"\2\2\2\u02dc\u02dd\5x=\2\u02dd\u02de\5z>\2\u02de\u02e2") buf.write(u"\3\2\2\2\u02df\u02e2\5x=\2\u02e0\u02e2\5z>\2\u02e1\u02d9") buf.write(u"\3\2\2\2\u02e1\u02dc\3\2\2\2\u02e1\u02df\3\2\2\2\u02e1") buf.write(u"\u02e0\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2Q\3\2\2\2\u02e3") buf.write(u"\u02ec\5P)\2\u02e4\u02ec\7\u00c3\2\2\u02e5\u02ec\7\u00b5") buf.write(u"\2\2\u02e6\u02ec\7\u00c0\2\2\u02e7\u02ec\7\u00b6\2\2") buf.write(u"\u02e8\u02ec\7\u00af\2\2\u02e9\u02ec\5T+\2\u02ea\u02ec") buf.write(u"\7\u00c4\2\2\u02eb\u02e3\3\2\2\2\u02eb\u02e4\3\2\2\2") buf.write(u"\u02eb\u02e5\3\2\2\2\u02eb\u02e6\3\2\2\2\u02eb\u02e7") buf.write(u"\3\2\2\2\u02eb\u02e8\3\2\2\2\u02eb\u02e9\3\2\2\2\u02eb") buf.write(u"\u02ea\3\2\2\2\u02ecS\3\2\2\2\u02ed\u02ee\7\u009c\2\2") buf.write(u"\u02ee\u02ef\79\2\2\u02ef\u02f0\5V,\2\u02f0\u02f1\7:") buf.write(u"\2\2\u02f1U\3\2\2\2\u02f2\u02f4\t\b\2\2\u02f3\u02f2\3") buf.write(u"\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f5") buf.write(u"\u02f6\3\2\2\2\u02f6W\3\2\2\2\u02f7\u02f8\7\u0098\2\2") buf.write(u"\u02f8\u02f9\79\2\2\u02f9\u02fa\5\"\22\2\u02fa\u02fb") buf.write(u"\7:\2\2\u02fb\u02fc\79\2\2\u02fc\u02fd\5\"\22\2\u02fd") buf.write(u"\u02fe\7:\2\2\u02feY\3\2\2\2\u02ff\u0300\79\2\2\u0300") buf.write(u"\u0301\5\"\22\2\u0301\u0302\7\u009a\2\2\u0302\u0303\5") buf.write(u"\"\22\2\u0303\u0304\7:\2\2\u0304\u030e\3\2\2\2\u0305") buf.write(u"\u0306\7\u0099\2\2\u0306\u0307\79\2\2\u0307\u0308\5\"") buf.write(u"\22\2\u0308\u0309\7:\2\2\u0309\u030a\79\2\2\u030a\u030b") buf.write(u"\5\"\22\2\u030b\u030c\7:\2\2\u030c\u030e\3\2\2\2\u030d") buf.write(u"\u02ff\3\2\2\2\u030d\u0305\3\2\2\2\u030e[\3\2\2\2\u030f") buf.write(u"\u0310\t\t\2\2\u0310]\3\2\2\2\u0311\u0312\t\n\2\2\u0312") buf.write(u"_\3\2\2\2\u0313\u0314\t\13\2\2\u0314a\3\2\2\2\u0315\u0316") buf.write(u"\t\f\2\2\u0316c\3\2\2\2\u0317\u031e\5\\/\2\u0318\u0319") buf.write(u"\7\u009d\2\2\u0319\u031a\79\2\2\u031a\u031b\5`\61\2\u031b") buf.write(u"\u031c\7:\2\2\u031c\u031e\3\2\2\2\u031d\u0317\3\2\2\2") buf.write(u"\u031d\u0318\3\2\2\2\u031ee\3\2\2\2\u031f\u0326\5^\60") buf.write(u"\2\u0320\u0321\7\u009d\2\2\u0321\u0322\79\2\2\u0322\u0323") buf.write(u"\5b\62\2\u0323\u0324\7:\2\2\u0324\u0326\3\2\2\2\u0325") buf.write(u"\u031f\3\2\2\2\u0325\u0320\3\2\2\2\u0326g\3\2\2\2\u0327") buf.write(u"\u0334\5d\63\2\u0328\u032a\5x=\2\u0329\u0328\3\2\2\2") buf.write(u"\u0329\u032a\3\2\2\2\u032a\u032c\3\2\2\2\u032b\u032d") buf.write(u"\5z>\2\u032c\u032b\3\2\2\2\u032c\u032d\3\2\2\2\u032d") buf.write(u"\u0335\3\2\2\2\u032e\u0330\5z>\2\u032f\u032e\3\2\2\2") buf.write(u"\u032f\u0330\3\2\2\2\u0330\u0332\3\2\2\2\u0331\u0333") buf.write(u"\5x=\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2\2\u0333") buf.write(u"\u0335\3\2\2\2\u0334\u0329\3\2\2\2\u0334\u032f\3\2\2") buf.write(u"\2\u0335\u034b\3\2\2\2\u0336\u0338\7P\2\2\u0337\u0336") buf.write(u"\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u0339\3\2\2\2\u0339") buf.write(u"\u033a\7\65\2\2\u033a\u033c\5p9\2\u033b\u033d\7Q\2\2") buf.write(u"\u033c\u033b\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033e") buf.write(u"\3\2\2\2\u033e\u033f\7\66\2\2\u033f\u034c\3\2\2\2\u0340") buf.write(u"\u0342\7R\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2\2") buf.write(u"\u0342\u0343\3\2\2\2\u0343\u0344\7\65\2\2\u0344\u0346") buf.write(u"\5p9\2\u0345\u0347\7S\2\2\u0346\u0345\3\2\2\2\u0346\u0347") buf.write(u"\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0349\7\66\2\2\u0349") buf.write(u"\u034c\3\2\2\2\u034a\u034c\5r:\2\u034b\u0337\3\2\2\2") buf.write(u"\u034b\u0341\3\2\2\2\u034b\u034a\3\2\2\2\u034c\u03ce") buf.write(u"\3\2\2\2\u034d\u035a\5f\64\2\u034e\u0350\5x=\2\u034f") buf.write(u"\u034e\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0352\3\2\2") buf.write(u"\2\u0351\u0353\5z>\2\u0352\u0351\3\2\2\2\u0352\u0353") buf.write(u"\3\2\2\2\u0353\u035b\3\2\2\2\u0354\u0356\5z>\2\u0355") buf.write(u"\u0354\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0358\3\2\2") buf.write(u"\2\u0357\u0359\5x=\2\u0358\u0357\3\2\2\2\u0358\u0359") buf.write(u"\3\2\2\2\u0359\u035b\3\2\2\2\u035a\u034f\3\2\2\2\u035a") buf.write(u"\u0355\3\2\2\2\u035b\u0371\3\2\2\2\u035c\u035e\7P\2\2") buf.write(u"\u035d\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f") buf.write(u"\3\2\2\2\u035f\u0360\7\65\2\2\u0360\u0362\5t;\2\u0361") buf.write(u"\u0363\7Q\2\2\u0362\u0361\3\2\2\2\u0362\u0363\3\2\2\2") buf.write(u"\u0363\u0364\3\2\2\2\u0364\u0365\7\66\2\2\u0365\u0372") buf.write(u"\3\2\2\2\u0366\u0368\7R\2\2\u0367\u0366\3\2\2\2\u0367") buf.write(u"\u0368\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036a\7\65\2") buf.write(u"\2\u036a\u036c\5t;\2\u036b\u036d\7S\2\2\u036c\u036b\3") buf.write(u"\2\2\2\u036c\u036d\3\2\2\2\u036d\u036e\3\2\2\2\u036e") buf.write(u"\u036f\7\66\2\2\u036f\u0372\3\2\2\2\u0370\u0372\5v<\2") buf.write(u"\u0371\u035d\3\2\2\2\u0371\u0367\3\2\2\2\u0371\u0370") buf.write(u"\3\2\2\2\u0372\u03ce\3\2\2\2\u0373\u0375\5N(\2\u0374") buf.write(u"\u0376\5z>\2\u0375\u0374\3\2\2\2\u0375\u0376\3\2\2\2") buf.write(u"\u0376\u0378\3\2\2\2\u0377\u0379\7P\2\2\u0378\u0377\3") buf.write(u"\2\2\2\u0378\u0379\3\2\2\2\u0379\u037a\3\2\2\2\u037a") buf.write(u"\u037b\t\r\2\2\u037b\u037c\5l\67\2\u037c\u037e\t\16\2") buf.write(u"\2\u037d\u037f\7Q\2\2\u037e\u037d\3\2\2\2\u037e\u037f") buf.write(u"\3\2\2\2\u037f\u03ce\3\2\2\2\u0380\u0382\5N(\2\u0381") buf.write(u"\u0383\5z>\2\u0382\u0381\3\2\2\2\u0382\u0383\3\2\2\2") buf.write(u"\u0383\u0384\3\2\2\2\u0384\u0386\79\2\2\u0385\u0387\7") buf.write(u"P\2\2\u0386\u0385\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u0388") buf.write(u"\3\2\2\2\u0388\u0389\t\r\2\2\u0389\u038a\5l\67\2\u038a") buf.write(u"\u038c\t\16\2\2\u038b\u038d\7Q\2\2\u038c\u038b\3\2\2") buf.write(u"\2\u038c\u038d\3\2\2\2\u038d\u038e\3\2\2\2\u038e\u038f") buf.write(u"\7:\2\2\u038f\u03ce\3\2\2\2\u0390\u03a5\7V\2\2\u0391") buf.write(u"\u0392\5x=\2\u0392\u0393\5z>\2\u0393\u03a6\3\2\2\2\u0394") buf.write(u"\u0395\5z>\2\u0395\u0396\5x=\2\u0396\u03a6\3\2\2\2\u0397") buf.write(u"\u0398\7\u00a9\2\2\u0398\u0399\79\2\2\u0399\u039a\7:") buf.write(u"\2\2\u039a\u039b\3\2\2\2\u039b\u039c\7\u00aa\2\2\u039c") buf.write(u"\u039d\79\2\2\u039d\u03a6\7:\2\2\u039e\u039f\7\u00aa") buf.write(u"\2\2\u039f\u03a0\79\2\2\u03a0\u03a1\7:\2\2\u03a1\u03a2") buf.write(u"\3\2\2\2\u03a2\u03a3\7\u00a9\2\2\u03a3\u03a4\79\2\2\u03a4") buf.write(u"\u03a6\7:\2\2\u03a5\u0391\3\2\2\2\u03a5\u0394\3\2\2\2") buf.write(u"\u03a5\u0397\3\2\2\2\u03a5\u039e\3\2\2\2\u03a5\u03a6") buf.write(u"\3\2\2\2\u03a6\u03ad\3\2\2\2\u03a7\u03a9\5$\23\2\u03a8") buf.write(u"\u03a7\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03aa\3\2\2") buf.write(u"\2\u03aa\u03ae\7\u00af\2\2\u03ab\u03ae\5X-\2\u03ac\u03ae") buf.write(u"\5$\23\2\u03ad\u03a8\3\2\2\2\u03ad\u03ab\3\2\2\2\u03ad") buf.write(u"\u03ac\3\2\2\2\u03ae\u03ce\3\2\2\2\u03af\u03b4\7{\2\2") buf.write(u"\u03b0\u03b1\7?\2\2\u03b1\u03b2\5\"\22\2\u03b2\u03b3") buf.write(u"\7@\2\2\u03b3\u03b5\3\2\2\2\u03b4\u03b0\3\2\2\2\u03b4") buf.write(u"\u03b5\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b7\79\2\2") buf.write(u"\u03b7\u03b8\5\"\22\2\u03b8\u03b9\7:\2\2\u03b9\u03ce") buf.write(u"\3\2\2\2\u03ba\u03c1\t\17\2\2\u03bb\u03bc\5|?\2\u03bc") buf.write(u"\u03bd\5z>\2\u03bd\u03c2\3\2\2\2\u03be\u03bf\5z>\2\u03bf") buf.write(u"\u03c0\5|?\2\u03c0\u03c2\3\2\2\2\u03c1\u03bb\3\2\2\2") buf.write(u"\u03c1\u03be\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c4") buf.write(u"\5&\24\2\u03c4\u03ce\3\2\2\2\u03c5\u03c6\7T\2\2\u03c6") buf.write(u"\u03c7\5n8\2\u03c7\u03c8\5&\24\2\u03c8\u03ce\3\2\2\2") buf.write(u"\u03c9\u03cb\7\u00b0\2\2\u03ca\u03cc\5z>\2\u03cb\u03ca") buf.write(u"\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u03ce\3\2\2\2\u03cd") buf.write(u"\u0327\3\2\2\2\u03cd\u034d\3\2\2\2\u03cd\u0373\3\2\2") buf.write(u"\2\u03cd\u0380\3\2\2\2\u03cd\u0390\3\2\2\2\u03cd\u03af") buf.write(u"\3\2\2\2\u03cd\u03ba\3\2\2\2\u03cd\u03c5\3\2\2\2\u03cd") buf.write(u"\u03c9\3\2\2\2\u03cei\3\2\2\2\u03cf\u03d0\5\"\22\2\u03d0") buf.write(u"\u03d1\7\u00ad\2\2\u03d1\u03d2\5j\66\2\u03d2\u03d5\3") buf.write(u"\2\2\2\u03d3\u03d5\5\"\22\2\u03d4\u03cf\3\2\2\2\u03d4") buf.write(u"\u03d3\3\2\2\2\u03d5k\3\2\2\2\u03d6\u03df\5R*\2\u03d7") buf.write(u"\u03d8\5\"\22\2\u03d8\u03d9\7\u00ad\2\2\u03d9\u03df\3") buf.write(u"\2\2\2\u03da\u03db\5\"\22\2\u03db\u03dc\7\u00ad\2\2\u03dc") buf.write(u"\u03dd\5j\66\2\u03dd\u03df\3\2\2\2\u03de\u03d6\3\2\2") buf.write(u"\2\u03de\u03d7\3\2\2\2\u03de\u03da\3\2\2\2\u03dfm\3\2") buf.write(u"\2\2\u03e0\u03e1\7\u00a9\2\2\u03e1\u03e2\79\2\2\u03e2") buf.write(u"\u03e3\t\20\2\2\u03e3\u03e4\7U\2\2\u03e4\u03e9\5\"\22") buf.write(u"\2\u03e5\u03e6\7\u00aa\2\2\u03e6\u03e7\79\2\2\u03e7\u03e8") buf.write(u"\t\6\2\2\u03e8\u03ea\7:\2\2\u03e9\u03e5\3\2\2\2\u03e9") buf.write(u"\u03ea\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\7:\2\2") buf.write(u"\u03eco\3\2\2\2\u03ed\u03ee\5\"\22\2\u03eeq\3\2\2\2\u03ef") buf.write(u"\u03f0\5(\25\2\u03f0s\3\2\2\2\u03f1\u03f7\5\"\22\2\u03f2") buf.write(u"\u03f3\5\"\22\2\u03f3\u03f4\7\u00ad\2\2\u03f4\u03f5\5") buf.write(u"t;\2\u03f5\u03f7\3\2\2\2\u03f6\u03f1\3\2\2\2\u03f6\u03f2") buf.write(u"\3\2\2\2\u03f7u\3\2\2\2\u03f8\u03f9\5(\25\2\u03f9w\3") buf.write(u"\2\2\2\u03fa\u0403\7\u00a9\2\2\u03fb\u0404\5R*\2\u03fc") buf.write(u"\u03ff\79\2\2\u03fd\u0400\5\"\22\2\u03fe\u0400\5j\66") buf.write(u"\2\u03ff\u03fd\3\2\2\2\u03ff\u03fe\3\2\2\2\u0400\u0401") buf.write(u"\3\2\2\2\u0401\u0402\7:\2\2\u0402\u0404\3\2\2\2\u0403") buf.write(u"\u03fb\3\2\2\2\u0403\u03fc\3\2\2\2\u0404y\3\2\2\2\u0405") buf.write(u"\u040b\7\u00aa\2\2\u0406\u040c\5R*\2\u0407\u0408\79\2") buf.write(u"\2\u0408\u0409\5\"\22\2\u0409\u040a\7:\2\2\u040a\u040c") buf.write(u"\3\2\2\2\u040b\u0406\3\2\2\2\u040b\u0407\3\2\2\2\u040c") buf.write(u"{\3\2\2\2\u040d\u040e\7\u00a9\2\2\u040e\u040f\79\2\2") buf.write(u"\u040f\u0410\5 \21\2\u0410\u0411\7:\2\2\u0411}\3\2\2") buf.write(u"\2\u0412\u0413\7\u00a9\2\2\u0413\u0414\79\2\2\u0414\u0415") buf.write(u"\5 \21\2\u0415\u0416\7:\2\2\u0416\177\3\2\2\2^\u0084") buf.write(u"\u008e\u0094\u00a2\u00a9\u00b2\u00b6\u00be\u00c4\u00cc") buf.write(u"\u00d0\u00d9\u00e4\u010c\u0115\u011f\u0122\u0132\u013d") buf.write(u"\u0148\u0150\u0152\u015a\u015d\u0163\u016a\u0170\u0178") buf.write(u"\u017e\u0186\u0194\u0197\u019b\u01a8\u01ab\u01af\u01bd") buf.write(u"\u01c9\u023b\u024d\u027f\u02a1\u02c3\u02ce\u02d1\u02d7") buf.write(u"\u02e1\u02eb\u02f5\u030d\u031d\u0325\u0329\u032c\u032f") buf.write(u"\u0332\u0334\u0337\u033c\u0341\u0346\u034b\u034f\u0352") buf.write(u"\u0355\u0358\u035a\u035d\u0362\u0367\u036c\u0371\u0375") buf.write(u"\u0378\u037e\u0382\u0386\u038c\u03a5\u03a8\u03ad\u03b4") buf.write(u"\u03c1\u03cb\u03cd\u03d4\u03de\u03e9\u03f6\u03ff\u0403") buf.write(u"\u040b") return buf.getvalue() class PSParser (Parser): grammarFileName = "PS.g4" atn = ATNDeserializer().deserialize(serializedATN()) decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] sharedContextCache = PredictionContextCache() literalNames = [u"", u"'\\acute'", u"'\\bar'", u"'\\overline'", u"'\\breve'", u"'\\check'", u"'\\widecheck'", u"'\\dot'", u"'\\ddot'", u"'\\grave'", u"'\\hat'", u"'\\tilde'", u"'\\widetilde'", u"'\\vec'", u"'\\overrightarrow'", u"'\\bm'", u"'\\boldsymbol'", u"'\\text'", u"'\\textit'", u"'\\mathbb'", u"'\\mathbin'", u"'\\mathbf'", u"'\\mathcal'", u"'\\mathclap'", u"'\\mathclose'", u"'\\mathellipsis'", u"'\\mathfrak'", u"'\\mathinner'", u"'\\mathnormal'", u"'\\mathop'", u"'\\mathopen'", u"'\\mathord'", u"'\\mathpunct'", u"'\\mathrel'", u"'\\mathring'", u"'\\mathrlap'", u"'\\mathrm'", u"'\\mathscr'", u"'\\mathsf'", u"'\\mathsterling'", u"'\\mathtt'", u"'^T'", u"'^{T}'", u"'^{\\top}'", u"'''", u"", u"'\\$'", u"'+'", u"'-'", u"'*'", u"", u"'('", u"')'", u"'\\lgroup'", u"'\\rgroup'", u"'{'", u"'}'", u"'\\{'", u"'\\}'", u"'\\lbrace'", u"'\\rbrace'", u"'['", u"']'", u"'\\lbrack'", u"'\\rbrack'", u"'|'", u"'\\lvert'", u"'\\rvert'", u"'\\vert'", u"'\\|'", u"'\\lfloor'", u"'\\rfloor'", u"'\\llcorner'", u"'\\lrcorner'", u"'\\lceil'", u"'\\rceil'", u"'\\ulcorner'", u"'\\urcorner'", u"'\\left'", u"'\\right'", u"'\\mleft'", u"'\\mright'", u"'\\lim'", u"", u"'\\int'", u"'\\sum'", u"'\\prod'", u"'\\log'", u"'\\ln'", u"'\\exp'", u"'\\sin'", u"'\\cos'", u"'\\tan'", u"'\\csc'", u"'\\sec'", u"'\\cot'", u"'\\arcsin'", u"'\\arccos'", u"'\\arctan'", u"'\\arccsc'", u"'\\arcsec'", u"'\\arccot'", u"'\\sinh'", u"'\\cosh'", u"'\\tanh'", u"'\\arsinh'", u"'\\arcosh'", u"'\\artanh'", u"'\\arcsinh'", u"'\\arccosh'", u"'\\arctanh'", u"'arsinh'", u"'arcsinh'", u"'arcosh'", u"'arccosh'", u"'artanh'", u"'arctanh'", u"'gcd'", u"'lcm'", u"'floor'", u"'ceil'", u"'\\sqrt'", u"'\\gcd'", u"'\\lcm'", u"'\\floor'", u"'\\ceil'", u"'\\max'", u"'\\min'", u"'\\det'", u"'eye'", u"'zeros'", u"'ones'", u"'cols'", u"'rows'", u"'diag'", u"'norm'", u"'rank'", u"", u"'rref'", u"'hstack'", u"'vstack'", u"", u"'nullspace'", u"", u"", u"", u"", u"'\\times'", u"'\\cdot'", u"'\\div'", u"'\\frac'", u"", u"'\\choose'", u"'\\mod'", u"'\\mathit'", u"'\\operatorname'", u"'matrix'", u"'pmatrix'", u"'bmatrix'", u"'vmatrix'", u"", u"", u"", u"", u"", u"'&'", u"'\\\\'", u"'_'", u"'^'", u"':'", u"';'", u"','", u"'.'", u"", u"", u"'E'", u"", u"", u"", u"", u"", u"'\\in'", u"'='", u"", u"'<'", u"", u"'>'", u"", u"", u"'!'"] symbolicNames = [u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"", u"WS", u"DOLLAR_SIGN", u"ADD", u"SUB", u"MUL", u"DIV", u"L_PAREN", u"R_PAREN", u"L_GROUP", u"R_GROUP", u"L_BRACE", u"R_BRACE", u"L_BRACE_VISUAL", u"R_BRACE_VISUAL", u"L_BRACE_CMD", u"R_BRACE_CMD", u"L_BRACKET", u"R_BRACKET", u"L_BRACK", u"R_BRACK", u"BAR", u"L_VERT", u"R_VERT", u"VERT", u"NORM", u"L_FLOOR", u"R_FLOOR", u"LL_CORNER", u"LR_CORNER", u"L_CEIL", u"R_CEIL", u"UL_CORNER", u"UR_CORNER", u"L_LEFT", u"R_RIGHT", u"ML_LEFT", u"MR_RIGHT", u"FUNC_LIM", u"LIM_APPROACH_SYM", u"FUNC_INT", u"FUNC_SUM", u"FUNC_PROD", u"FUNC_LOG", u"FUNC_LN", u"FUNC_EXP", u"FUNC_SIN", u"FUNC_COS", u"FUNC_TAN", u"FUNC_CSC", u"FUNC_SEC", u"FUNC_COT", u"FUNC_ARCSIN", u"FUNC_ARCCOS", u"FUNC_ARCTAN", u"FUNC_ARCCSC", u"FUNC_ARCSEC", u"FUNC_ARCCOT", u"FUNC_SINH", u"FUNC_COSH", u"FUNC_TANH", u"FUNC_ARSINH", u"FUNC_ARCOSH", u"FUNC_ARTANH", u"FUNC_ARCSINH", u"FUNC_ARCCOSH", u"FUNC_ARCTANH", u"FUNC_ARSINH_NAME", u"FUNC_ARCSINH_NAME", u"FUNC_ARCOSH_NAME", u"FUNC_ARCCOSH_NAME", u"FUNC_ARTANH_NAME", u"FUNC_ARCTANH_NAME", u"FUNC_GCD_NAME", u"FUNC_LCM_NAME", u"FUNC_FLOOR_NAME", u"FUNC_CEIL_NAME", u"FUNC_SQRT", u"FUNC_GCD", u"FUNC_LCM", u"FUNC_FLOOR", u"FUNC_CEIL", u"FUNC_MAX", u"FUNC_MIN", u"FUNC_DET", u"FUNC_EYE_NAME", u"FUNC_ZEROS_NAME", u"FUNC_ONES_NAME", u"FUNC_COLS_NAME", u"FUNC_ROWS_NAME", u"FUNC_DIAG_NAME", u"FUNC_NORM_NAME", u"FUNC_RANK_NAME", u"FUNC_TRACE_NAME", u"FUNC_RREF_NAME", u"FUNC_HSTACK_NAME", u"FUNC_VSTACK_NAME", u"FUNC_ORTHOGONALIZE_NAME", u"FUNC_NULLSPACE_NAME", u"FUNC_DIAGONALIZE_NAME", u"FUNC_EIGENVALS_NAME", u"FUNC_EIGENVECTORS_NAME", u"FUNC_SVD_NAME", u"CMD_TIMES", u"CMD_CDOT", u"CMD_DIV", u"CMD_FRAC", u"CMD_BINOM", u"CMD_CHOOSE", u"CMD_MOD", u"CMD_MATHIT", u"CMD_OPERATORNAME", u"MATRIX_TYPE_MATRIX", u"MATRIX_TYPE_PMATRIX", u"MATRIX_TYPE_BMATRIX", u"MATRIX_TYPE_DET", u"MATRIX_TYPES", u"CMD_MATRIX_START", u"CMD_MATRIX_END", u"CMD_DET_START", u"CMD_DET_END", u"MATRIX_DEL_COL", u"MATRIX_DEL_ROW", u"UNDERSCORE", u"CARET", u"COLON", u"SEMICOLON", u"COMMA", u"PERIOD", u"DIFFERENTIAL", u"EXP_E", u"E_NOTATION_E", u"LETTER_NO_E", u"MATRIX_XRIGHTARROW", u"TRANSFORM_EXCHANGE", u"NUMBER", u"E_NOTATION", u"IN", u"ASSIGNMENT", u"EQUAL", u"LT", u"LTE", u"GT", u"GTE", u"UNEQUAL", u"BANG", u"PERCENT_NUMBER", u"GREEK_CMD", u"OTHER_SYMBOL_CMD", u"SYMBOL", u"VARIABLE"] RULE_accent_symbol = 0 RULE_math = 1 RULE_transpose = 2 RULE_transform_atom = 3 RULE_transform_scale = 4 RULE_transform_swap = 5 RULE_transform_assignment = 6 RULE_elementary_transform = 7 RULE_elementary_transforms = 8 RULE_matrix = 9 RULE_det = 10 RULE_matrix_row = 11 RULE_relation = 12 RULE_relation_list = 13 RULE_relation_list_content = 14 RULE_equality = 15 RULE_expr = 16 RULE_additive = 17 RULE_mp = 18 RULE_mp_nofunc = 19 RULE_unary = 20 RULE_unary_nofunc = 21 RULE_postfix = 22 RULE_postfix_nofunc = 23 RULE_postfix_op = 24 RULE_eval_at = 25 RULE_eval_at_sub = 26 RULE_eval_at_sup = 27 RULE_exp = 28 RULE_exp_nofunc = 29 RULE_comp = 30 RULE_comp_nofunc = 31 RULE_group = 32 RULE_norm_group = 33 RULE_abs_group = 34 RULE_floor_group = 35 RULE_ceil_group = 36 RULE_accent = 37 RULE_atom_expr_no_supexpr = 38 RULE_atom_expr = 39 RULE_atom = 40 RULE_mathit = 41 RULE_mathit_text = 42 RULE_frac = 43 RULE_binom = 44 RULE_func_normal_functions_single_arg = 45 RULE_func_normal_functions_multi_arg = 46 RULE_func_operator_names_single_arg = 47 RULE_func_operator_names_multi_arg = 48 RULE_func_normal_single_arg = 49 RULE_func_normal_multi_arg = 50 RULE_func = 51 RULE_args = 52 RULE_func_common_args = 53 RULE_limit_sub = 54 RULE_func_single_arg = 55 RULE_func_single_arg_noparens = 56 RULE_func_multi_arg = 57 RULE_func_multi_arg_noparens = 58 RULE_subexpr = 59 RULE_supexpr = 60 RULE_subeq = 61 RULE_supeq = 62 ruleNames = [u"accent_symbol", u"math", u"transpose", u"transform_atom", u"transform_scale", u"transform_swap", u"transform_assignment", u"elementary_transform", u"elementary_transforms", u"matrix", u"det", u"matrix_row", u"relation", u"relation_list", u"relation_list_content", u"equality", u"expr", u"additive", u"mp", u"mp_nofunc", u"unary", u"unary_nofunc", u"postfix", u"postfix_nofunc", u"postfix_op", u"eval_at", u"eval_at_sub", u"eval_at_sup", u"exp", u"exp_nofunc", u"comp", u"comp_nofunc", u"group", u"norm_group", u"abs_group", u"floor_group", u"ceil_group", u"accent", u"atom_expr_no_supexpr", u"atom_expr", u"atom", u"mathit", u"mathit_text", u"frac", u"binom", u"func_normal_functions_single_arg", u"func_normal_functions_multi_arg", u"func_operator_names_single_arg", u"func_operator_names_multi_arg", u"func_normal_single_arg", u"func_normal_multi_arg", u"func", u"args", u"func_common_args", u"limit_sub", u"func_single_arg", u"func_single_arg_noparens", u"func_multi_arg", u"func_multi_arg_noparens", u"subexpr", u"supexpr", u"subeq", u"supeq"] EOF = Token.EOF T__0 = 1 T__1 = 2 T__2 = 3 T__3 = 4 T__4 = 5 T__5 = 6 T__6 = 7 T__7 = 8 T__8 = 9 T__9 = 10 T__10 = 11 T__11 = 12 T__12 = 13 T__13 = 14 T__14 = 15 T__15 = 16 T__16 = 17 T__17 = 18 T__18 = 19 T__19 = 20 T__20 = 21 T__21 = 22 T__22 = 23 T__23 = 24 T__24 = 25 T__25 = 26 T__26 = 27 T__27 = 28 T__28 = 29 T__29 = 30 T__30 = 31 T__31 = 32 T__32 = 33 T__33 = 34 T__34 = 35 T__35 = 36 T__36 = 37 T__37 = 38 T__38 = 39 T__39 = 40 T__40 = 41 T__41 = 42 T__42 = 43 T__43 = 44 WS = 45 DOLLAR_SIGN = 46 ADD = 47 SUB = 48 MUL = 49 DIV = 50 L_PAREN = 51 R_PAREN = 52 L_GROUP = 53 R_GROUP = 54 L_BRACE = 55 R_BRACE = 56 L_BRACE_VISUAL = 57 R_BRACE_VISUAL = 58 L_BRACE_CMD = 59 R_BRACE_CMD = 60 L_BRACKET = 61 R_BRACKET = 62 L_BRACK = 63 R_BRACK = 64 BAR = 65 L_VERT = 66 R_VERT = 67 VERT = 68 NORM = 69 L_FLOOR = 70 R_FLOOR = 71 LL_CORNER = 72 LR_CORNER = 73 L_CEIL = 74 R_CEIL = 75 UL_CORNER = 76 UR_CORNER = 77 L_LEFT = 78 R_RIGHT = 79 ML_LEFT = 80 MR_RIGHT = 81 FUNC_LIM = 82 LIM_APPROACH_SYM = 83 FUNC_INT = 84 FUNC_SUM = 85 FUNC_PROD = 86 FUNC_LOG = 87 FUNC_LN = 88 FUNC_EXP = 89 FUNC_SIN = 90 FUNC_COS = 91 FUNC_TAN = 92 FUNC_CSC = 93 FUNC_SEC = 94 FUNC_COT = 95 FUNC_ARCSIN = 96 FUNC_ARCCOS = 97 FUNC_ARCTAN = 98 FUNC_ARCCSC = 99 FUNC_ARCSEC = 100 FUNC_ARCCOT = 101 FUNC_SINH = 102 FUNC_COSH = 103 FUNC_TANH = 104 FUNC_ARSINH = 105 FUNC_ARCOSH = 106 FUNC_ARTANH = 107 FUNC_ARCSINH = 108 FUNC_ARCCOSH = 109 FUNC_ARCTANH = 110 FUNC_ARSINH_NAME = 111 FUNC_ARCSINH_NAME = 112 FUNC_ARCOSH_NAME = 113 FUNC_ARCCOSH_NAME = 114 FUNC_ARTANH_NAME = 115 FUNC_ARCTANH_NAME = 116 FUNC_GCD_NAME = 117 FUNC_LCM_NAME = 118 FUNC_FLOOR_NAME = 119 FUNC_CEIL_NAME = 120 FUNC_SQRT = 121 FUNC_GCD = 122 FUNC_LCM = 123 FUNC_FLOOR = 124 FUNC_CEIL = 125 FUNC_MAX = 126 FUNC_MIN = 127 FUNC_DET = 128 FUNC_EYE_NAME = 129 FUNC_ZEROS_NAME = 130 FUNC_ONES_NAME = 131 FUNC_COLS_NAME = 132 FUNC_ROWS_NAME = 133 FUNC_DIAG_NAME = 134 FUNC_NORM_NAME = 135 FUNC_RANK_NAME = 136 FUNC_TRACE_NAME = 137 FUNC_RREF_NAME = 138 FUNC_HSTACK_NAME = 139 FUNC_VSTACK_NAME = 140 FUNC_ORTHOGONALIZE_NAME = 141 FUNC_NULLSPACE_NAME = 142 FUNC_DIAGONALIZE_NAME = 143 FUNC_EIGENVALS_NAME = 144 FUNC_EIGENVECTORS_NAME = 145 FUNC_SVD_NAME = 146 CMD_TIMES = 147 CMD_CDOT = 148 CMD_DIV = 149 CMD_FRAC = 150 CMD_BINOM = 151 CMD_CHOOSE = 152 CMD_MOD = 153 CMD_MATHIT = 154 CMD_OPERATORNAME = 155 MATRIX_TYPE_MATRIX = 156 MATRIX_TYPE_PMATRIX = 157 MATRIX_TYPE_BMATRIX = 158 MATRIX_TYPE_DET = 159 MATRIX_TYPES = 160 CMD_MATRIX_START = 161 CMD_MATRIX_END = 162 CMD_DET_START = 163 CMD_DET_END = 164 MATRIX_DEL_COL = 165 MATRIX_DEL_ROW = 166 UNDERSCORE = 167 CARET = 168 COLON = 169 SEMICOLON = 170 COMMA = 171 PERIOD = 172 DIFFERENTIAL = 173 EXP_E = 174 E_NOTATION_E = 175 LETTER_NO_E = 176 MATRIX_XRIGHTARROW = 177 TRANSFORM_EXCHANGE = 178 NUMBER = 179 E_NOTATION = 180 IN = 181 ASSIGNMENT = 182 EQUAL = 183 LT = 184 LTE = 185 GT = 186 GTE = 187 UNEQUAL = 188 BANG = 189 PERCENT_NUMBER = 190 GREEK_CMD = 191 OTHER_SYMBOL_CMD = 192 SYMBOL = 193 VARIABLE = 194 def __init__(self, input, output=sys.stdout): super(PSParser, self).__init__(input, output=output) self.checkVersion("4.7.2") self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) self._predicates = None class Accent_symbolContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Accent_symbolContext, self).__init__(parent, invokingState) self.parser = parser def CMD_MATHIT(self): return self.getToken(PSParser.CMD_MATHIT, 0) def getRuleIndex(self): return PSParser.RULE_accent_symbol def enterRule(self, listener): if hasattr(listener, "enterAccent_symbol"): listener.enterAccent_symbol(self) def exitRule(self, listener): if hasattr(listener, "exitAccent_symbol"): listener.exitAccent_symbol(self) def accent_symbol(self): localctx = PSParser.Accent_symbolContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_accent_symbol) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 126 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PSParser.T__0) | (1 << PSParser.T__1) | (1 << PSParser.T__2) | (1 << PSParser.T__3) | (1 << PSParser.T__4) | (1 << PSParser.T__5) | (1 << PSParser.T__6) | (1 << PSParser.T__7) | (1 << PSParser.T__8) | (1 << PSParser.T__9) | (1 << PSParser.T__10) | (1 << PSParser.T__11) | (1 << PSParser.T__12) | (1 << PSParser.T__13) | (1 << PSParser.T__14) | (1 << PSParser.T__15) | (1 << PSParser.T__16) | (1 << PSParser.T__17) | (1 << PSParser.T__18) | (1 << PSParser.T__19) | (1 << PSParser.T__20) | (1 << PSParser.T__21) | (1 << PSParser.T__22) | (1 << PSParser.T__23) | (1 << PSParser.T__24) | (1 << PSParser.T__25) | (1 << PSParser.T__26) | (1 << PSParser.T__27) | (1 << PSParser.T__28) | (1 << PSParser.T__29) | (1 << PSParser.T__30) | (1 << PSParser.T__31) | (1 << PSParser.T__32) | (1 << PSParser.T__33) | (1 << PSParser.T__34) | (1 << PSParser.T__35) | (1 << PSParser.T__36) | (1 << PSParser.T__37) | (1 << PSParser.T__38) | (1 << PSParser.T__39))) != 0) or _la == PSParser.CMD_MATHIT): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class MathContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.MathContext, self).__init__(parent, invokingState) self.parser = parser def relation(self): return self.getTypedRuleContext(PSParser.RelationContext, 0) def relation_list(self): return self.getTypedRuleContext(PSParser.Relation_listContext, 0) def getRuleIndex(self): return PSParser.RULE_math def enterRule(self, listener): if hasattr(listener, "enterMath"): listener.enterMath(self) def exitRule(self, listener): if hasattr(listener, "exitMath"): listener.exitMath(self) def math(self): localctx = PSParser.MathContext(self, self._ctx, self.state) self.enterRule(localctx, 2, self.RULE_math) try: self.state = 130 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 0, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 128 self.relation(0) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 129 self.relation_list() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class TransposeContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.TransposeContext, self).__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return PSParser.RULE_transpose def enterRule(self, listener): if hasattr(listener, "enterTranspose"): listener.enterTranspose(self) def exitRule(self, listener): if hasattr(listener, "exitTranspose"): listener.exitTranspose(self) def transpose(self): localctx = PSParser.TransposeContext(self, self._ctx, self.state) self.enterRule(localctx, 4, self.RULE_transpose) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 132 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PSParser.T__40) | (1 << PSParser.T__41) | (1 << PSParser.T__42) | (1 << PSParser.T__43))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Transform_atomContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Transform_atomContext, self).__init__(parent, invokingState) self.parser = parser def LETTER_NO_E(self): return self.getToken(PSParser.LETTER_NO_E, 0) def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def NUMBER(self): return self.getToken(PSParser.NUMBER, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def getRuleIndex(self): return PSParser.RULE_transform_atom def enterRule(self, listener): if hasattr(listener, "enterTransform_atom"): listener.enterTransform_atom(self) def exitRule(self, listener): if hasattr(listener, "exitTransform_atom"): listener.exitTransform_atom(self) def transform_atom(self): localctx = PSParser.Transform_atomContext(self, self._ctx, self.state) self.enterRule(localctx, 6, self.RULE_transform_atom) try: self.enterOuterAlt(localctx, 1) self.state = 134 self.match(PSParser.LETTER_NO_E) self.state = 135 self.match(PSParser.UNDERSCORE) self.state = 140 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.NUMBER]: self.state = 136 self.match(PSParser.NUMBER) pass elif token in [PSParser.L_BRACE]: self.state = 137 self.match(PSParser.L_BRACE) self.state = 138 self.match(PSParser.NUMBER) self.state = 139 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Transform_scaleContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Transform_scaleContext, self).__init__(parent, invokingState) self.parser = parser def transform_atom(self): return self.getTypedRuleContext(PSParser.Transform_atomContext, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def group(self): return self.getTypedRuleContext(PSParser.GroupContext, 0) def ADD(self): return self.getToken(PSParser.ADD, 0) def SUB(self): return self.getToken(PSParser.SUB, 0) def getRuleIndex(self): return PSParser.RULE_transform_scale def enterRule(self, listener): if hasattr(listener, "enterTransform_scale"): listener.enterTransform_scale(self) def exitRule(self, listener): if hasattr(listener, "exitTransform_scale"): listener.exitTransform_scale(self) def transform_scale(self): localctx = PSParser.Transform_scaleContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_transform_scale) try: self.enterOuterAlt(localctx, 1) self.state = 146 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 2, self._ctx) if la_ == 1: self.state = 142 self.expr() pass elif la_ == 2: self.state = 143 self.group() pass elif la_ == 3: self.state = 144 self.match(PSParser.ADD) pass elif la_ == 4: self.state = 145 self.match(PSParser.SUB) pass self.state = 148 self.transform_atom() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Transform_swapContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Transform_swapContext, self).__init__(parent, invokingState) self.parser = parser def transform_atom(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Transform_atomContext) else: return self.getTypedRuleContext(PSParser.Transform_atomContext, i) def TRANSFORM_EXCHANGE(self): return self.getToken(PSParser.TRANSFORM_EXCHANGE, 0) def getRuleIndex(self): return PSParser.RULE_transform_swap def enterRule(self, listener): if hasattr(listener, "enterTransform_swap"): listener.enterTransform_swap(self) def exitRule(self, listener): if hasattr(listener, "exitTransform_swap"): listener.exitTransform_swap(self) def transform_swap(self): localctx = PSParser.Transform_swapContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_transform_swap) try: self.enterOuterAlt(localctx, 1) self.state = 150 self.transform_atom() self.state = 151 self.match(PSParser.TRANSFORM_EXCHANGE) self.state = 152 self.transform_atom() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Transform_assignmentContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Transform_assignmentContext, self).__init__(parent, invokingState) self.parser = parser def transform_atom(self): return self.getTypedRuleContext(PSParser.Transform_atomContext, 0) def transform_scale(self): return self.getTypedRuleContext(PSParser.Transform_scaleContext, 0) def getRuleIndex(self): return PSParser.RULE_transform_assignment def enterRule(self, listener): if hasattr(listener, "enterTransform_assignment"): listener.enterTransform_assignment(self) def exitRule(self, listener): if hasattr(listener, "exitTransform_assignment"): listener.exitTransform_assignment(self) def transform_assignment(self): localctx = PSParser.Transform_assignmentContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_transform_assignment) try: self.enterOuterAlt(localctx, 1) self.state = 154 self.transform_atom() self.state = 155 self.transform_scale() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Elementary_transformContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Elementary_transformContext, self).__init__(parent, invokingState) self.parser = parser def transform_assignment(self): return self.getTypedRuleContext(PSParser.Transform_assignmentContext, 0) def transform_scale(self): return self.getTypedRuleContext(PSParser.Transform_scaleContext, 0) def transform_swap(self): return self.getTypedRuleContext(PSParser.Transform_swapContext, 0) def getRuleIndex(self): return PSParser.RULE_elementary_transform def enterRule(self, listener): if hasattr(listener, "enterElementary_transform"): listener.enterElementary_transform(self) def exitRule(self, listener): if hasattr(listener, "exitElementary_transform"): listener.exitElementary_transform(self) def elementary_transform(self): localctx = PSParser.Elementary_transformContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_elementary_transform) try: self.state = 160 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 3, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 157 self.transform_assignment() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 158 self.transform_scale() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 159 self.transform_swap() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Elementary_transformsContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Elementary_transformsContext, self).__init__(parent, invokingState) self.parser = parser def elementary_transform(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Elementary_transformContext) else: return self.getTypedRuleContext(PSParser.Elementary_transformContext, i) def COMMA(self, i=None): if i is None: return self.getTokens(PSParser.COMMA) else: return self.getToken(PSParser.COMMA, i) def getRuleIndex(self): return PSParser.RULE_elementary_transforms def enterRule(self, listener): if hasattr(listener, "enterElementary_transforms"): listener.enterElementary_transforms(self) def exitRule(self, listener): if hasattr(listener, "exitElementary_transforms"): listener.exitElementary_transforms(self) def elementary_transforms(self): localctx = PSParser.Elementary_transformsContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_elementary_transforms) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 162 self.elementary_transform() self.state = 167 self._errHandler.sync(self) _la = self._input.LA(1) while _la == PSParser.COMMA: self.state = 163 self.match(PSParser.COMMA) self.state = 164 self.elementary_transform() self.state = 169 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class MatrixContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.MatrixContext, self).__init__(parent, invokingState) self.parser = parser def CMD_MATRIX_START(self): return self.getToken(PSParser.CMD_MATRIX_START, 0) def matrix_row(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Matrix_rowContext) else: return self.getTypedRuleContext(PSParser.Matrix_rowContext, i) def CMD_MATRIX_END(self): return self.getToken(PSParser.CMD_MATRIX_END, 0) def MATRIX_DEL_ROW(self, i=None): if i is None: return self.getTokens(PSParser.MATRIX_DEL_ROW) else: return self.getToken(PSParser.MATRIX_DEL_ROW, i) def MATRIX_XRIGHTARROW(self): return self.getToken(PSParser.MATRIX_XRIGHTARROW, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def elementary_transforms(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Elementary_transformsContext) else: return self.getTypedRuleContext(PSParser.Elementary_transformsContext, i) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def L_BRACKET(self): return self.getToken(PSParser.L_BRACKET, 0) def R_BRACKET(self): return self.getToken(PSParser.R_BRACKET, 0) def getRuleIndex(self): return PSParser.RULE_matrix def enterRule(self, listener): if hasattr(listener, "enterMatrix"): listener.enterMatrix(self) def exitRule(self, listener): if hasattr(listener, "exitMatrix"): listener.exitMatrix(self) def matrix(self): localctx = PSParser.MatrixContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_matrix) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 170 self.match(PSParser.CMD_MATRIX_START) self.state = 171 self.matrix_row() self.state = 176 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 5, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 172 self.match(PSParser.MATRIX_DEL_ROW) self.state = 173 self.matrix_row() self.state = 178 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 5, self._ctx) self.state = 180 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.MATRIX_DEL_ROW: self.state = 179 self.match(PSParser.MATRIX_DEL_ROW) self.state = 182 self.match(PSParser.CMD_MATRIX_END) self.state = 194 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) if la_ == 1: self.state = 183 self.match(PSParser.MATRIX_XRIGHTARROW) self.state = 188 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_BRACKET: self.state = 184 self.match(PSParser.L_BRACKET) self.state = 185 self.elementary_transforms() self.state = 186 self.match(PSParser.R_BRACKET) self.state = 190 self.match(PSParser.L_BRACE) self.state = 191 self.elementary_transforms() self.state = 192 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class DetContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.DetContext, self).__init__(parent, invokingState) self.parser = parser def CMD_DET_START(self): return self.getToken(PSParser.CMD_DET_START, 0) def matrix_row(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Matrix_rowContext) else: return self.getTypedRuleContext(PSParser.Matrix_rowContext, i) def CMD_DET_END(self): return self.getToken(PSParser.CMD_DET_END, 0) def MATRIX_DEL_ROW(self, i=None): if i is None: return self.getTokens(PSParser.MATRIX_DEL_ROW) else: return self.getToken(PSParser.MATRIX_DEL_ROW, i) def getRuleIndex(self): return PSParser.RULE_det def enterRule(self, listener): if hasattr(listener, "enterDet"): listener.enterDet(self) def exitRule(self, listener): if hasattr(listener, "exitDet"): listener.exitDet(self) def det(self): localctx = PSParser.DetContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_det) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 196 self.match(PSParser.CMD_DET_START) self.state = 197 self.matrix_row() self.state = 202 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 9, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 198 self.match(PSParser.MATRIX_DEL_ROW) self.state = 199 self.matrix_row() self.state = 204 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 9, self._ctx) self.state = 206 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.MATRIX_DEL_ROW: self.state = 205 self.match(PSParser.MATRIX_DEL_ROW) self.state = 208 self.match(PSParser.CMD_DET_END) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Matrix_rowContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Matrix_rowContext, self).__init__(parent, invokingState) self.parser = parser def expr(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.ExprContext) else: return self.getTypedRuleContext(PSParser.ExprContext, i) def MATRIX_DEL_COL(self, i=None): if i is None: return self.getTokens(PSParser.MATRIX_DEL_COL) else: return self.getToken(PSParser.MATRIX_DEL_COL, i) def getRuleIndex(self): return PSParser.RULE_matrix_row def enterRule(self, listener): if hasattr(listener, "enterMatrix_row"): listener.enterMatrix_row(self) def exitRule(self, listener): if hasattr(listener, "exitMatrix_row"): listener.exitMatrix_row(self) def matrix_row(self): localctx = PSParser.Matrix_rowContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_matrix_row) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 210 self.expr() self.state = 215 self._errHandler.sync(self) _la = self._input.LA(1) while _la == PSParser.MATRIX_DEL_COL: self.state = 211 self.match(PSParser.MATRIX_DEL_COL) self.state = 212 self.expr() self.state = 217 self._errHandler.sync(self) _la = self._input.LA(1) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class RelationContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.RelationContext, self).__init__(parent, invokingState) self.parser = parser def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def relation(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.RelationContext) else: return self.getTypedRuleContext(PSParser.RelationContext, i) def IN(self): return self.getToken(PSParser.IN, 0) def ASSIGNMENT(self): return self.getToken(PSParser.ASSIGNMENT, 0) def EQUAL(self): return self.getToken(PSParser.EQUAL, 0) def LT(self): return self.getToken(PSParser.LT, 0) def LTE(self): return self.getToken(PSParser.LTE, 0) def GT(self): return self.getToken(PSParser.GT, 0) def GTE(self): return self.getToken(PSParser.GTE, 0) def UNEQUAL(self): return self.getToken(PSParser.UNEQUAL, 0) def getRuleIndex(self): return PSParser.RULE_relation def enterRule(self, listener): if hasattr(listener, "enterRelation"): listener.enterRelation(self) def exitRule(self, listener): if hasattr(listener, "exitRelation"): listener.exitRelation(self) def relation(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.RelationContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 24 self.enterRecursionRule(localctx, 24, self.RULE_relation, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 219 self.expr() self._ctx.stop = self._input.LT(-1) self.state = 226 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 12, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.RelationContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_relation) self.state = 221 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 222 _la = self._input.LA(1) if not(((((_la - 181)) & ~0x3f) == 0 and ((1 << (_la - 181)) & ((1 << (PSParser.IN - 181)) | (1 << (PSParser.ASSIGNMENT - 181)) | (1 << (PSParser.EQUAL - 181)) | (1 << (PSParser.LT - 181)) | (1 << (PSParser.LTE - 181)) | (1 << (PSParser.GT - 181)) | (1 << (PSParser.GTE - 181)) | (1 << (PSParser.UNEQUAL - 181)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 223 self.relation(3) self.state = 228 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 12, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class Relation_listContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Relation_listContext, self).__init__(parent, invokingState) self.parser = parser def relation_list_content(self): return self.getTypedRuleContext(PSParser.Relation_list_contentContext, 0) def L_BRACKET(self): return self.getToken(PSParser.L_BRACKET, 0) def R_BRACKET(self): return self.getToken(PSParser.R_BRACKET, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def L_BRACE_VISUAL(self): return self.getToken(PSParser.L_BRACE_VISUAL, 0) def R_BRACE_VISUAL(self): return self.getToken(PSParser.R_BRACE_VISUAL, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_relation_list def enterRule(self, listener): if hasattr(listener, "enterRelation_list"): listener.enterRelation_list(self) def exitRule(self, listener): if hasattr(listener, "exitRelation_list"): listener.exitRelation_list(self) def relation_list(self): localctx = PSParser.Relation_listContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_relation_list) try: self.state = 266 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 229 self.relation_list_content() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 230 self.match(PSParser.L_BRACKET) self.state = 231 self.relation_list_content() self.state = 232 self.match(PSParser.R_BRACKET) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 234 self.match(PSParser.L_BRACE) self.state = 235 self.relation_list_content() self.state = 236 self.match(PSParser.R_BRACE) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 238 self.match(PSParser.L_BRACE_VISUAL) self.state = 239 self.relation_list_content() self.state = 240 self.match(PSParser.R_BRACE_VISUAL) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 242 self.match(PSParser.L_LEFT) self.state = 243 self.match(PSParser.L_BRACKET) self.state = 244 self.relation_list_content() self.state = 245 self.match(PSParser.R_RIGHT) self.state = 246 self.match(PSParser.R_BRACKET) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 248 self.match(PSParser.L_LEFT) self.state = 249 self.match(PSParser.L_BRACE_VISUAL) self.state = 250 self.relation_list_content() self.state = 251 self.match(PSParser.R_RIGHT) self.state = 252 self.match(PSParser.R_BRACE_VISUAL) pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 254 self.match(PSParser.ML_LEFT) self.state = 255 self.match(PSParser.L_BRACKET) self.state = 256 self.relation_list_content() self.state = 257 self.match(PSParser.MR_RIGHT) self.state = 258 self.match(PSParser.R_BRACKET) pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 260 self.match(PSParser.ML_LEFT) self.state = 261 self.match(PSParser.L_BRACE_VISUAL) self.state = 262 self.relation_list_content() self.state = 263 self.match(PSParser.MR_RIGHT) self.state = 264 self.match(PSParser.R_BRACE_VISUAL) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Relation_list_contentContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Relation_list_contentContext, self).__init__(parent, invokingState) self.parser = parser def relation(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.RelationContext) else: return self.getTypedRuleContext(PSParser.RelationContext, i) def COMMA(self, i=None): if i is None: return self.getTokens(PSParser.COMMA) else: return self.getToken(PSParser.COMMA, i) def SEMICOLON(self, i=None): if i is None: return self.getTokens(PSParser.SEMICOLON) else: return self.getToken(PSParser.SEMICOLON, i) def getRuleIndex(self): return PSParser.RULE_relation_list_content def enterRule(self, listener): if hasattr(listener, "enterRelation_list_content"): listener.enterRelation_list_content(self) def exitRule(self, listener): if hasattr(listener, "exitRelation_list_content"): listener.exitRelation_list_content(self) def relation_list_content(self): localctx = PSParser.Relation_list_contentContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_relation_list_content) self._la = 0 # Token type try: self.state = 288 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 16, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 268 self.relation(0) self.state = 269 self.match(PSParser.COMMA) self.state = 270 self.relation(0) self.state = 275 self._errHandler.sync(self) _la = self._input.LA(1) while _la == PSParser.COMMA: self.state = 271 self.match(PSParser.COMMA) self.state = 272 self.relation(0) self.state = 277 self._errHandler.sync(self) _la = self._input.LA(1) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 278 self.relation(0) self.state = 279 self.match(PSParser.SEMICOLON) self.state = 280 self.relation(0) self.state = 285 self._errHandler.sync(self) _la = self._input.LA(1) while _la == PSParser.SEMICOLON: self.state = 281 self.match(PSParser.SEMICOLON) self.state = 282 self.relation(0) self.state = 287 self._errHandler.sync(self) _la = self._input.LA(1) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class EqualityContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.EqualityContext, self).__init__(parent, invokingState) self.parser = parser def expr(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.ExprContext) else: return self.getTypedRuleContext(PSParser.ExprContext, i) def EQUAL(self): return self.getToken(PSParser.EQUAL, 0) def ASSIGNMENT(self): return self.getToken(PSParser.ASSIGNMENT, 0) def getRuleIndex(self): return PSParser.RULE_equality def enterRule(self, listener): if hasattr(listener, "enterEquality"): listener.enterEquality(self) def exitRule(self, listener): if hasattr(listener, "exitEquality"): listener.exitEquality(self) def equality(self): localctx = PSParser.EqualityContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_equality) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 290 self.expr() self.state = 291 _la = self._input.LA(1) if not(_la == PSParser.ASSIGNMENT or _la == PSParser.EQUAL): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 292 self.expr() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExprContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.ExprContext, self).__init__(parent, invokingState) self.parser = parser def additive(self): return self.getTypedRuleContext(PSParser.AdditiveContext, 0) def getRuleIndex(self): return PSParser.RULE_expr def enterRule(self, listener): if hasattr(listener, "enterExpr"): listener.enterExpr(self) def exitRule(self, listener): if hasattr(listener, "exitExpr"): listener.exitExpr(self) def expr(self): localctx = PSParser.ExprContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_expr) try: self.enterOuterAlt(localctx, 1) self.state = 294 self.additive(0) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AdditiveContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.AdditiveContext, self).__init__(parent, invokingState) self.parser = parser def mp(self): return self.getTypedRuleContext(PSParser.MpContext, 0) def additive(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.AdditiveContext) else: return self.getTypedRuleContext(PSParser.AdditiveContext, i) def ADD(self): return self.getToken(PSParser.ADD, 0) def SUB(self): return self.getToken(PSParser.SUB, 0) def getRuleIndex(self): return PSParser.RULE_additive def enterRule(self, listener): if hasattr(listener, "enterAdditive"): listener.enterAdditive(self) def exitRule(self, listener): if hasattr(listener, "exitAdditive"): listener.exitAdditive(self) def additive(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.AdditiveContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 34 self.enterRecursionRule(localctx, 34, self.RULE_additive, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 297 self.mp(0) self._ctx.stop = self._input.LT(-1) self.state = 304 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 17, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.AdditiveContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_additive) self.state = 299 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 300 _la = self._input.LA(1) if not(_la == PSParser.ADD or _la == PSParser.SUB): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 301 self.additive(3) self.state = 306 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 17, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class MpContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.MpContext, self).__init__(parent, invokingState) self.parser = parser def unary(self): return self.getTypedRuleContext(PSParser.UnaryContext, 0) def mp(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.MpContext) else: return self.getTypedRuleContext(PSParser.MpContext, i) def MUL(self): return self.getToken(PSParser.MUL, 0) def CMD_TIMES(self): return self.getToken(PSParser.CMD_TIMES, 0) def CMD_CDOT(self): return self.getToken(PSParser.CMD_CDOT, 0) def DIV(self): return self.getToken(PSParser.DIV, 0) def CMD_DIV(self): return self.getToken(PSParser.CMD_DIV, 0) def COLON(self): return self.getToken(PSParser.COLON, 0) def CMD_MOD(self): return self.getToken(PSParser.CMD_MOD, 0) def getRuleIndex(self): return PSParser.RULE_mp def enterRule(self, listener): if hasattr(listener, "enterMp"): listener.enterMp(self) def exitRule(self, listener): if hasattr(listener, "exitMp"): listener.exitMp(self) def mp(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.MpContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 36 self.enterRecursionRule(localctx, 36, self.RULE_mp, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 308 self.unary() self._ctx.stop = self._input.LT(-1) self.state = 315 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 18, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.MpContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_mp) self.state = 310 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 311 _la = self._input.LA(1) if not(_la == PSParser.MUL or _la == PSParser.DIV or ((((_la - 147)) & ~0x3f) == 0 and ((1 << (_la - 147)) & ((1 << (PSParser.CMD_TIMES - 147)) | (1 << (PSParser.CMD_CDOT - 147)) | (1 << (PSParser.CMD_DIV - 147)) | (1 << (PSParser.CMD_MOD - 147)) | (1 << (PSParser.COLON - 147)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 312 self.mp(3) self.state = 317 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 18, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class Mp_nofuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Mp_nofuncContext, self).__init__(parent, invokingState) self.parser = parser def unary_nofunc(self): return self.getTypedRuleContext(PSParser.Unary_nofuncContext, 0) def mp_nofunc(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Mp_nofuncContext) else: return self.getTypedRuleContext(PSParser.Mp_nofuncContext, i) def MUL(self): return self.getToken(PSParser.MUL, 0) def CMD_TIMES(self): return self.getToken(PSParser.CMD_TIMES, 0) def CMD_CDOT(self): return self.getToken(PSParser.CMD_CDOT, 0) def DIV(self): return self.getToken(PSParser.DIV, 0) def CMD_DIV(self): return self.getToken(PSParser.CMD_DIV, 0) def COLON(self): return self.getToken(PSParser.COLON, 0) def CMD_MOD(self): return self.getToken(PSParser.CMD_MOD, 0) def getRuleIndex(self): return PSParser.RULE_mp_nofunc def enterRule(self, listener): if hasattr(listener, "enterMp_nofunc"): listener.enterMp_nofunc(self) def exitRule(self, listener): if hasattr(listener, "exitMp_nofunc"): listener.exitMp_nofunc(self) def mp_nofunc(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.Mp_nofuncContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 38 self.enterRecursionRule(localctx, 38, self.RULE_mp_nofunc, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 319 self.unary_nofunc() self._ctx.stop = self._input.LT(-1) self.state = 326 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 19, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.Mp_nofuncContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_mp_nofunc) self.state = 321 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 322 _la = self._input.LA(1) if not(_la == PSParser.MUL or _la == PSParser.DIV or ((((_la - 147)) & ~0x3f) == 0 and ((1 << (_la - 147)) & ((1 << (PSParser.CMD_TIMES - 147)) | (1 << (PSParser.CMD_CDOT - 147)) | (1 << (PSParser.CMD_DIV - 147)) | (1 << (PSParser.CMD_MOD - 147)) | (1 << (PSParser.COLON - 147)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 323 self.mp_nofunc(3) self.state = 328 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 19, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class UnaryContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.UnaryContext, self).__init__(parent, invokingState) self.parser = parser def unary(self): return self.getTypedRuleContext(PSParser.UnaryContext, 0) def ADD(self): return self.getToken(PSParser.ADD, 0) def SUB(self): return self.getToken(PSParser.SUB, 0) def postfix(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.PostfixContext) else: return self.getTypedRuleContext(PSParser.PostfixContext, i) def getRuleIndex(self): return PSParser.RULE_unary def enterRule(self, listener): if hasattr(listener, "enterUnary"): listener.enterUnary(self) def exitRule(self, listener): if hasattr(listener, "exitUnary"): listener.exitUnary(self) def unary(self): localctx = PSParser.UnaryContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_unary) self._la = 0 # Token type try: self.state = 336 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.ADD, PSParser.SUB]: self.enterOuterAlt(localctx, 1) self.state = 329 _la = self._input.LA(1) if not(_la == PSParser.ADD or _la == PSParser.SUB): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 330 self.unary() pass elif token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.L_PAREN, PSParser.L_GROUP, PSParser.L_BRACE, PSParser.L_BRACE_VISUAL, PSParser.L_BRACE_CMD, PSParser.L_BRACKET, PSParser.L_BRACK, PSParser.BAR, PSParser.L_VERT, PSParser.VERT, PSParser.NORM, PSParser.L_FLOOR, PSParser.LL_CORNER, PSParser.L_CEIL, PSParser.UL_CORNER, PSParser.L_LEFT, PSParser.ML_LEFT, PSParser.FUNC_LIM, PSParser.FUNC_INT, PSParser.FUNC_SUM, PSParser.FUNC_PROD, PSParser.FUNC_LOG, PSParser.FUNC_LN, PSParser.FUNC_EXP, PSParser.FUNC_SIN, PSParser.FUNC_COS, PSParser.FUNC_TAN, PSParser.FUNC_CSC, PSParser.FUNC_SEC, PSParser.FUNC_COT, PSParser.FUNC_ARCSIN, PSParser.FUNC_ARCCOS, PSParser.FUNC_ARCTAN, PSParser.FUNC_ARCCSC, PSParser.FUNC_ARCSEC, PSParser.FUNC_ARCCOT, PSParser.FUNC_SINH, PSParser.FUNC_COSH, PSParser.FUNC_TANH, PSParser.FUNC_ARSINH, PSParser.FUNC_ARCOSH, PSParser.FUNC_ARTANH, PSParser.FUNC_ARCSINH, PSParser.FUNC_ARCCOSH, PSParser.FUNC_ARCTANH, PSParser.FUNC_SQRT, PSParser.FUNC_GCD, PSParser.FUNC_LCM, PSParser.FUNC_FLOOR, PSParser.FUNC_CEIL, PSParser.FUNC_MAX, PSParser.FUNC_MIN, PSParser.FUNC_DET, PSParser.CMD_FRAC, PSParser.CMD_BINOM, PSParser.CMD_MATHIT, PSParser.CMD_OPERATORNAME, PSParser.CMD_MATRIX_START, PSParser.CMD_DET_START, PSParser.DIFFERENTIAL, PSParser.EXP_E, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.enterOuterAlt(localctx, 2) self.state = 332 self._errHandler.sync(self) _alt = 1 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 331 self.postfix() else: raise NoViableAltException(self) self.state = 334 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 20, self._ctx) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Unary_nofuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Unary_nofuncContext, self).__init__(parent, invokingState) self.parser = parser def unary_nofunc(self): return self.getTypedRuleContext(PSParser.Unary_nofuncContext, 0) def ADD(self): return self.getToken(PSParser.ADD, 0) def SUB(self): return self.getToken(PSParser.SUB, 0) def postfix(self): return self.getTypedRuleContext(PSParser.PostfixContext, 0) def postfix_nofunc(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Postfix_nofuncContext) else: return self.getTypedRuleContext(PSParser.Postfix_nofuncContext, i) def getRuleIndex(self): return PSParser.RULE_unary_nofunc def enterRule(self, listener): if hasattr(listener, "enterUnary_nofunc"): listener.enterUnary_nofunc(self) def exitRule(self, listener): if hasattr(listener, "exitUnary_nofunc"): listener.exitUnary_nofunc(self) def unary_nofunc(self): localctx = PSParser.Unary_nofuncContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_unary_nofunc) self._la = 0 # Token type try: self.state = 347 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.ADD, PSParser.SUB]: self.enterOuterAlt(localctx, 1) self.state = 338 _la = self._input.LA(1) if not(_la == PSParser.ADD or _la == PSParser.SUB): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 339 self.unary_nofunc() pass elif token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.L_PAREN, PSParser.L_GROUP, PSParser.L_BRACE, PSParser.L_BRACE_VISUAL, PSParser.L_BRACE_CMD, PSParser.L_BRACKET, PSParser.L_BRACK, PSParser.BAR, PSParser.L_VERT, PSParser.VERT, PSParser.NORM, PSParser.L_FLOOR, PSParser.LL_CORNER, PSParser.L_CEIL, PSParser.UL_CORNER, PSParser.L_LEFT, PSParser.ML_LEFT, PSParser.FUNC_LIM, PSParser.FUNC_INT, PSParser.FUNC_SUM, PSParser.FUNC_PROD, PSParser.FUNC_LOG, PSParser.FUNC_LN, PSParser.FUNC_EXP, PSParser.FUNC_SIN, PSParser.FUNC_COS, PSParser.FUNC_TAN, PSParser.FUNC_CSC, PSParser.FUNC_SEC, PSParser.FUNC_COT, PSParser.FUNC_ARCSIN, PSParser.FUNC_ARCCOS, PSParser.FUNC_ARCTAN, PSParser.FUNC_ARCCSC, PSParser.FUNC_ARCSEC, PSParser.FUNC_ARCCOT, PSParser.FUNC_SINH, PSParser.FUNC_COSH, PSParser.FUNC_TANH, PSParser.FUNC_ARSINH, PSParser.FUNC_ARCOSH, PSParser.FUNC_ARTANH, PSParser.FUNC_ARCSINH, PSParser.FUNC_ARCCOSH, PSParser.FUNC_ARCTANH, PSParser.FUNC_SQRT, PSParser.FUNC_GCD, PSParser.FUNC_LCM, PSParser.FUNC_FLOOR, PSParser.FUNC_CEIL, PSParser.FUNC_MAX, PSParser.FUNC_MIN, PSParser.FUNC_DET, PSParser.CMD_FRAC, PSParser.CMD_BINOM, PSParser.CMD_MATHIT, PSParser.CMD_OPERATORNAME, PSParser.CMD_MATRIX_START, PSParser.CMD_DET_START, PSParser.DIFFERENTIAL, PSParser.EXP_E, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.enterOuterAlt(localctx, 2) self.state = 340 self.postfix() self.state = 344 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 22, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 341 self.postfix_nofunc() self.state = 346 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 22, self._ctx) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class PostfixContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.PostfixContext, self).__init__(parent, invokingState) self.parser = parser def exp(self): return self.getTypedRuleContext(PSParser.ExpContext, 0) def postfix_op(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Postfix_opContext) else: return self.getTypedRuleContext(PSParser.Postfix_opContext, i) def getRuleIndex(self): return PSParser.RULE_postfix def enterRule(self, listener): if hasattr(listener, "enterPostfix"): listener.enterPostfix(self) def exitRule(self, listener): if hasattr(listener, "exitPostfix"): listener.exitPostfix(self) def postfix(self): localctx = PSParser.PostfixContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_postfix) try: self.enterOuterAlt(localctx, 1) self.state = 349 self.exp(0) self.state = 353 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 24, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 350 self.postfix_op() self.state = 355 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 24, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Postfix_nofuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Postfix_nofuncContext, self).__init__(parent, invokingState) self.parser = parser def exp_nofunc(self): return self.getTypedRuleContext(PSParser.Exp_nofuncContext, 0) def postfix_op(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.Postfix_opContext) else: return self.getTypedRuleContext(PSParser.Postfix_opContext, i) def getRuleIndex(self): return PSParser.RULE_postfix_nofunc def enterRule(self, listener): if hasattr(listener, "enterPostfix_nofunc"): listener.enterPostfix_nofunc(self) def exitRule(self, listener): if hasattr(listener, "exitPostfix_nofunc"): listener.exitPostfix_nofunc(self) def postfix_nofunc(self): localctx = PSParser.Postfix_nofuncContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_postfix_nofunc) try: self.enterOuterAlt(localctx, 1) self.state = 356 self.exp_nofunc(0) self.state = 360 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 25, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: self.state = 357 self.postfix_op() self.state = 362 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 25, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Postfix_opContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Postfix_opContext, self).__init__(parent, invokingState) self.parser = parser def BANG(self): return self.getToken(PSParser.BANG, 0) def eval_at(self): return self.getTypedRuleContext(PSParser.Eval_atContext, 0) def transpose(self): return self.getTypedRuleContext(PSParser.TransposeContext, 0) def getRuleIndex(self): return PSParser.RULE_postfix_op def enterRule(self, listener): if hasattr(listener, "enterPostfix_op"): listener.enterPostfix_op(self) def exitRule(self, listener): if hasattr(listener, "exitPostfix_op"): listener.exitPostfix_op(self) def postfix_op(self): localctx = PSParser.Postfix_opContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_postfix_op) try: self.state = 366 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.BANG]: self.enterOuterAlt(localctx, 1) self.state = 363 self.match(PSParser.BANG) pass elif token in [PSParser.BAR]: self.enterOuterAlt(localctx, 2) self.state = 364 self.eval_at() pass elif token in [PSParser.T__40, PSParser.T__41, PSParser.T__42, PSParser.T__43]: self.enterOuterAlt(localctx, 3) self.state = 365 self.transpose() pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Eval_atContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Eval_atContext, self).__init__(parent, invokingState) self.parser = parser def BAR(self): return self.getToken(PSParser.BAR, 0) def eval_at_sup(self): return self.getTypedRuleContext(PSParser.Eval_at_supContext, 0) def eval_at_sub(self): return self.getTypedRuleContext(PSParser.Eval_at_subContext, 0) def getRuleIndex(self): return PSParser.RULE_eval_at def enterRule(self, listener): if hasattr(listener, "enterEval_at"): listener.enterEval_at(self) def exitRule(self, listener): if hasattr(listener, "exitEval_at"): listener.exitEval_at(self) def eval_at(self): localctx = PSParser.Eval_atContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_eval_at) try: self.enterOuterAlt(localctx, 1) self.state = 368 self.match(PSParser.BAR) self.state = 374 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 27, self._ctx) if la_ == 1: self.state = 369 self.eval_at_sup() pass elif la_ == 2: self.state = 370 self.eval_at_sub() pass elif la_ == 3: self.state = 371 self.eval_at_sup() self.state = 372 self.eval_at_sub() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Eval_at_subContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Eval_at_subContext, self).__init__(parent, invokingState) self.parser = parser def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def equality(self): return self.getTypedRuleContext(PSParser.EqualityContext, 0) def getRuleIndex(self): return PSParser.RULE_eval_at_sub def enterRule(self, listener): if hasattr(listener, "enterEval_at_sub"): listener.enterEval_at_sub(self) def exitRule(self, listener): if hasattr(listener, "exitEval_at_sub"): listener.exitEval_at_sub(self) def eval_at_sub(self): localctx = PSParser.Eval_at_subContext(self, self._ctx, self.state) self.enterRule(localctx, 52, self.RULE_eval_at_sub) try: self.enterOuterAlt(localctx, 1) self.state = 376 self.match(PSParser.UNDERSCORE) self.state = 377 self.match(PSParser.L_BRACE) self.state = 380 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 28, self._ctx) if la_ == 1: self.state = 378 self.expr() pass elif la_ == 2: self.state = 379 self.equality() pass self.state = 382 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Eval_at_supContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Eval_at_supContext, self).__init__(parent, invokingState) self.parser = parser def CARET(self): return self.getToken(PSParser.CARET, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def equality(self): return self.getTypedRuleContext(PSParser.EqualityContext, 0) def getRuleIndex(self): return PSParser.RULE_eval_at_sup def enterRule(self, listener): if hasattr(listener, "enterEval_at_sup"): listener.enterEval_at_sup(self) def exitRule(self, listener): if hasattr(listener, "exitEval_at_sup"): listener.exitEval_at_sup(self) def eval_at_sup(self): localctx = PSParser.Eval_at_supContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_eval_at_sup) try: self.enterOuterAlt(localctx, 1) self.state = 384 self.match(PSParser.CARET) self.state = 385 self.match(PSParser.L_BRACE) self.state = 388 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 29, self._ctx) if la_ == 1: self.state = 386 self.expr() pass elif la_ == 2: self.state = 387 self.equality() pass self.state = 390 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ExpContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.ExpContext, self).__init__(parent, invokingState) self.parser = parser def comp(self): return self.getTypedRuleContext(PSParser.CompContext, 0) def exp(self): return self.getTypedRuleContext(PSParser.ExpContext, 0) def CARET(self): return self.getToken(PSParser.CARET, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def subexpr(self): return self.getTypedRuleContext(PSParser.SubexprContext, 0) def getRuleIndex(self): return PSParser.RULE_exp def enterRule(self, listener): if hasattr(listener, "enterExp"): listener.enterExp(self) def exitRule(self, listener): if hasattr(listener, "exitExp"): listener.exitExp(self) def exp(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.ExpContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 56 self.enterRecursionRule(localctx, 56, self.RULE_exp, _p) try: self.enterOuterAlt(localctx, 1) self.state = 393 self.comp() self._ctx.stop = self._input.LT(-1) self.state = 409 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 32, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.ExpContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_exp) self.state = 395 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 396 self.match(PSParser.CARET) self.state = 402 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT, PSParser.DIFFERENTIAL, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.state = 397 self.atom() pass elif token in [PSParser.L_BRACE]: self.state = 398 self.match(PSParser.L_BRACE) self.state = 399 self.expr() self.state = 400 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) self.state = 405 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 31, self._ctx) if la_ == 1: self.state = 404 self.subexpr() self.state = 411 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 32, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class Exp_nofuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Exp_nofuncContext, self).__init__(parent, invokingState) self.parser = parser def comp_nofunc(self): return self.getTypedRuleContext(PSParser.Comp_nofuncContext, 0) def exp_nofunc(self): return self.getTypedRuleContext(PSParser.Exp_nofuncContext, 0) def CARET(self): return self.getToken(PSParser.CARET, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def subexpr(self): return self.getTypedRuleContext(PSParser.SubexprContext, 0) def getRuleIndex(self): return PSParser.RULE_exp_nofunc def enterRule(self, listener): if hasattr(listener, "enterExp_nofunc"): listener.enterExp_nofunc(self) def exitRule(self, listener): if hasattr(listener, "exitExp_nofunc"): listener.exitExp_nofunc(self) def exp_nofunc(self, _p=0): _parentctx = self._ctx _parentState = self.state localctx = PSParser.Exp_nofuncContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 58 self.enterRecursionRule(localctx, 58, self.RULE_exp_nofunc, _p) try: self.enterOuterAlt(localctx, 1) self.state = 413 self.comp_nofunc() self._ctx.stop = self._input.LT(-1) self.state = 429 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 35, self._ctx) while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = PSParser.Exp_nofuncContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_exp_nofunc) self.state = 415 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 416 self.match(PSParser.CARET) self.state = 422 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT, PSParser.DIFFERENTIAL, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.state = 417 self.atom() pass elif token in [PSParser.L_BRACE]: self.state = 418 self.match(PSParser.L_BRACE) self.state = 419 self.expr() self.state = 420 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) self.state = 425 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 34, self._ctx) if la_ == 1: self.state = 424 self.subexpr() self.state = 431 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input, 35, self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class CompContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.CompContext, self).__init__(parent, invokingState) self.parser = parser def group(self): return self.getTypedRuleContext(PSParser.GroupContext, 0) def norm_group(self): return self.getTypedRuleContext(PSParser.Norm_groupContext, 0) def abs_group(self): return self.getTypedRuleContext(PSParser.Abs_groupContext, 0) def floor_group(self): return self.getTypedRuleContext(PSParser.Floor_groupContext, 0) def ceil_group(self): return self.getTypedRuleContext(PSParser.Ceil_groupContext, 0) def func(self): return self.getTypedRuleContext(PSParser.FuncContext, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def frac(self): return self.getTypedRuleContext(PSParser.FracContext, 0) def binom(self): return self.getTypedRuleContext(PSParser.BinomContext, 0) def matrix(self): return self.getTypedRuleContext(PSParser.MatrixContext, 0) def det(self): return self.getTypedRuleContext(PSParser.DetContext, 0) def getRuleIndex(self): return PSParser.RULE_comp def enterRule(self, listener): if hasattr(listener, "enterComp"): listener.enterComp(self) def exitRule(self, listener): if hasattr(listener, "exitComp"): listener.exitComp(self) def comp(self): localctx = PSParser.CompContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_comp) try: self.state = 443 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 36, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 432 self.group() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 433 self.norm_group() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 434 self.abs_group() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 435 self.floor_group() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 436 self.ceil_group() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 437 self.func() pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 438 self.atom() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 439 self.frac() pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 440 self.binom() pass elif la_ == 10: self.enterOuterAlt(localctx, 10) self.state = 441 self.matrix() pass elif la_ == 11: self.enterOuterAlt(localctx, 11) self.state = 442 self.det() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Comp_nofuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Comp_nofuncContext, self).__init__(parent, invokingState) self.parser = parser def group(self): return self.getTypedRuleContext(PSParser.GroupContext, 0) def norm_group(self): return self.getTypedRuleContext(PSParser.Norm_groupContext, 0) def abs_group(self): return self.getTypedRuleContext(PSParser.Abs_groupContext, 0) def floor_group(self): return self.getTypedRuleContext(PSParser.Floor_groupContext, 0) def ceil_group(self): return self.getTypedRuleContext(PSParser.Ceil_groupContext, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def frac(self): return self.getTypedRuleContext(PSParser.FracContext, 0) def binom(self): return self.getTypedRuleContext(PSParser.BinomContext, 0) def matrix(self): return self.getTypedRuleContext(PSParser.MatrixContext, 0) def det(self): return self.getTypedRuleContext(PSParser.DetContext, 0) def getRuleIndex(self): return PSParser.RULE_comp_nofunc def enterRule(self, listener): if hasattr(listener, "enterComp_nofunc"): listener.enterComp_nofunc(self) def exitRule(self, listener): if hasattr(listener, "exitComp_nofunc"): listener.exitComp_nofunc(self) def comp_nofunc(self): localctx = PSParser.Comp_nofuncContext(self, self._ctx, self.state) self.enterRule(localctx, 62, self.RULE_comp_nofunc) try: self.state = 455 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 37, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 445 self.group() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 446 self.norm_group() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 447 self.abs_group() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 448 self.floor_group() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 449 self.ceil_group() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 450 self.atom() pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 451 self.frac() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 452 self.binom() pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 453 self.matrix() pass elif la_ == 10: self.enterOuterAlt(localctx, 10) self.state = 454 self.det() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class GroupContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.GroupContext, self).__init__(parent, invokingState) self.parser = parser def L_PAREN(self): return self.getToken(PSParser.L_PAREN, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_PAREN(self): return self.getToken(PSParser.R_PAREN, 0) def L_GROUP(self): return self.getToken(PSParser.L_GROUP, 0) def R_GROUP(self): return self.getToken(PSParser.R_GROUP, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def L_BRACE_VISUAL(self): return self.getToken(PSParser.L_BRACE_VISUAL, 0) def R_BRACE_VISUAL(self): return self.getToken(PSParser.R_BRACE_VISUAL, 0) def L_BRACE_CMD(self): return self.getToken(PSParser.L_BRACE_CMD, 0) def R_BRACE_CMD(self): return self.getToken(PSParser.R_BRACE_CMD, 0) def L_BRACKET(self): return self.getToken(PSParser.L_BRACKET, 0) def R_BRACKET(self): return self.getToken(PSParser.R_BRACKET, 0) def L_BRACK(self): return self.getToken(PSParser.L_BRACK, 0) def R_BRACK(self): return self.getToken(PSParser.R_BRACK, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_group def enterRule(self, listener): if hasattr(listener, "enterGroup"): listener.enterGroup(self) def exitRule(self, listener): if hasattr(listener, "exitGroup"): listener.exitGroup(self) def group(self): localctx = PSParser.GroupContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_group) try: self.state = 569 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 38, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 457 self.match(PSParser.L_PAREN) self.state = 458 self.expr() self.state = 459 self.match(PSParser.R_PAREN) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 461 self.match(PSParser.L_GROUP) self.state = 462 self.expr() self.state = 463 self.match(PSParser.R_GROUP) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 465 self.match(PSParser.L_BRACE) self.state = 466 self.expr() self.state = 467 self.match(PSParser.R_BRACE) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 469 self.match(PSParser.L_BRACE_VISUAL) self.state = 470 self.expr() self.state = 471 self.match(PSParser.R_BRACE_VISUAL) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 473 self.match(PSParser.L_BRACE_CMD) self.state = 474 self.expr() self.state = 475 self.match(PSParser.R_BRACE_CMD) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 477 self.match(PSParser.L_BRACKET) self.state = 478 self.expr() self.state = 479 self.match(PSParser.R_BRACKET) pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 481 self.match(PSParser.L_BRACK) self.state = 482 self.expr() self.state = 483 self.match(PSParser.R_BRACK) pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 485 self.match(PSParser.L_LEFT) self.state = 486 self.match(PSParser.L_PAREN) self.state = 487 self.expr() self.state = 488 self.match(PSParser.R_RIGHT) self.state = 489 self.match(PSParser.R_PAREN) pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 491 self.match(PSParser.L_LEFT) self.state = 492 self.match(PSParser.L_GROUP) self.state = 493 self.expr() self.state = 494 self.match(PSParser.R_RIGHT) self.state = 495 self.match(PSParser.R_GROUP) pass elif la_ == 10: self.enterOuterAlt(localctx, 10) self.state = 497 self.match(PSParser.L_LEFT) self.state = 498 self.match(PSParser.L_BRACE) self.state = 499 self.expr() self.state = 500 self.match(PSParser.R_RIGHT) self.state = 501 self.match(PSParser.R_BRACE) pass elif la_ == 11: self.enterOuterAlt(localctx, 11) self.state = 503 self.match(PSParser.L_LEFT) self.state = 504 self.match(PSParser.L_BRACE_VISUAL) self.state = 505 self.expr() self.state = 506 self.match(PSParser.R_RIGHT) self.state = 507 self.match(PSParser.R_BRACE_VISUAL) pass elif la_ == 12: self.enterOuterAlt(localctx, 12) self.state = 509 self.match(PSParser.L_LEFT) self.state = 510 self.match(PSParser.L_BRACE_CMD) self.state = 511 self.expr() self.state = 512 self.match(PSParser.R_RIGHT) self.state = 513 self.match(PSParser.R_BRACE_CMD) pass elif la_ == 13: self.enterOuterAlt(localctx, 13) self.state = 515 self.match(PSParser.L_LEFT) self.state = 516 self.match(PSParser.L_BRACKET) self.state = 517 self.expr() self.state = 518 self.match(PSParser.R_RIGHT) self.state = 519 self.match(PSParser.R_BRACKET) pass elif la_ == 14: self.enterOuterAlt(localctx, 14) self.state = 521 self.match(PSParser.L_LEFT) self.state = 522 self.match(PSParser.L_BRACK) self.state = 523 self.expr() self.state = 524 self.match(PSParser.R_RIGHT) self.state = 525 self.match(PSParser.R_BRACK) pass elif la_ == 15: self.enterOuterAlt(localctx, 15) self.state = 527 self.match(PSParser.ML_LEFT) self.state = 528 self.match(PSParser.L_PAREN) self.state = 529 self.expr() self.state = 530 self.match(PSParser.MR_RIGHT) self.state = 531 self.match(PSParser.R_PAREN) pass elif la_ == 16: self.enterOuterAlt(localctx, 16) self.state = 533 self.match(PSParser.ML_LEFT) self.state = 534 self.match(PSParser.L_GROUP) self.state = 535 self.expr() self.state = 536 self.match(PSParser.MR_RIGHT) self.state = 537 self.match(PSParser.R_GROUP) pass elif la_ == 17: self.enterOuterAlt(localctx, 17) self.state = 539 self.match(PSParser.ML_LEFT) self.state = 540 self.match(PSParser.L_BRACE) self.state = 541 self.expr() self.state = 542 self.match(PSParser.MR_RIGHT) self.state = 543 self.match(PSParser.R_BRACE) pass elif la_ == 18: self.enterOuterAlt(localctx, 18) self.state = 545 self.match(PSParser.ML_LEFT) self.state = 546 self.match(PSParser.L_BRACE_VISUAL) self.state = 547 self.expr() self.state = 548 self.match(PSParser.MR_RIGHT) self.state = 549 self.match(PSParser.R_BRACE_VISUAL) pass elif la_ == 19: self.enterOuterAlt(localctx, 19) self.state = 551 self.match(PSParser.ML_LEFT) self.state = 552 self.match(PSParser.L_BRACE_CMD) self.state = 553 self.expr() self.state = 554 self.match(PSParser.MR_RIGHT) self.state = 555 self.match(PSParser.R_BRACE_CMD) pass elif la_ == 20: self.enterOuterAlt(localctx, 20) self.state = 557 self.match(PSParser.ML_LEFT) self.state = 558 self.match(PSParser.L_BRACKET) self.state = 559 self.expr() self.state = 560 self.match(PSParser.MR_RIGHT) self.state = 561 self.match(PSParser.R_BRACKET) pass elif la_ == 21: self.enterOuterAlt(localctx, 21) self.state = 563 self.match(PSParser.ML_LEFT) self.state = 564 self.match(PSParser.L_BRACK) self.state = 565 self.expr() self.state = 566 self.match(PSParser.MR_RIGHT) self.state = 567 self.match(PSParser.R_BRACK) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Norm_groupContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Norm_groupContext, self).__init__(parent, invokingState) self.parser = parser def NORM(self, i=None): if i is None: return self.getTokens(PSParser.NORM) else: return self.getToken(PSParser.NORM, i) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_norm_group def enterRule(self, listener): if hasattr(listener, "enterNorm_group"): listener.enterNorm_group(self) def exitRule(self, listener): if hasattr(listener, "exitNorm_group"): listener.exitNorm_group(self) def norm_group(self): localctx = PSParser.Norm_groupContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_norm_group) try: self.state = 587 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.NORM]: self.enterOuterAlt(localctx, 1) self.state = 571 self.match(PSParser.NORM) self.state = 572 self.expr() self.state = 573 self.match(PSParser.NORM) pass elif token in [PSParser.L_LEFT]: self.enterOuterAlt(localctx, 2) self.state = 575 self.match(PSParser.L_LEFT) self.state = 576 self.match(PSParser.NORM) self.state = 577 self.expr() self.state = 578 self.match(PSParser.R_RIGHT) self.state = 579 self.match(PSParser.NORM) pass elif token in [PSParser.ML_LEFT]: self.enterOuterAlt(localctx, 3) self.state = 581 self.match(PSParser.ML_LEFT) self.state = 582 self.match(PSParser.NORM) self.state = 583 self.expr() self.state = 584 self.match(PSParser.MR_RIGHT) self.state = 585 self.match(PSParser.NORM) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Abs_groupContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Abs_groupContext, self).__init__(parent, invokingState) self.parser = parser def BAR(self, i=None): if i is None: return self.getTokens(PSParser.BAR) else: return self.getToken(PSParser.BAR, i) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def L_VERT(self): return self.getToken(PSParser.L_VERT, 0) def R_VERT(self): return self.getToken(PSParser.R_VERT, 0) def VERT(self, i=None): if i is None: return self.getTokens(PSParser.VERT) else: return self.getToken(PSParser.VERT, i) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_abs_group def enterRule(self, listener): if hasattr(listener, "enterAbs_group"): listener.enterAbs_group(self) def exitRule(self, listener): if hasattr(listener, "exitAbs_group"): listener.exitAbs_group(self) def abs_group(self): localctx = PSParser.Abs_groupContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_abs_group) try: self.state = 637 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 40, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 589 self.match(PSParser.BAR) self.state = 590 self.expr() self.state = 591 self.match(PSParser.BAR) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 593 self.match(PSParser.L_VERT) self.state = 594 self.expr() self.state = 595 self.match(PSParser.R_VERT) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 597 self.match(PSParser.VERT) self.state = 598 self.expr() self.state = 599 self.match(PSParser.VERT) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 601 self.match(PSParser.L_LEFT) self.state = 602 self.match(PSParser.BAR) self.state = 603 self.expr() self.state = 604 self.match(PSParser.R_RIGHT) self.state = 605 self.match(PSParser.BAR) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 607 self.match(PSParser.L_LEFT) self.state = 608 self.match(PSParser.L_VERT) self.state = 609 self.expr() self.state = 610 self.match(PSParser.R_RIGHT) self.state = 611 self.match(PSParser.R_VERT) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 613 self.match(PSParser.L_LEFT) self.state = 614 self.match(PSParser.VERT) self.state = 615 self.expr() self.state = 616 self.match(PSParser.R_RIGHT) self.state = 617 self.match(PSParser.VERT) pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 619 self.match(PSParser.ML_LEFT) self.state = 620 self.match(PSParser.BAR) self.state = 621 self.expr() self.state = 622 self.match(PSParser.MR_RIGHT) self.state = 623 self.match(PSParser.BAR) pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 625 self.match(PSParser.ML_LEFT) self.state = 626 self.match(PSParser.L_VERT) self.state = 627 self.expr() self.state = 628 self.match(PSParser.MR_RIGHT) self.state = 629 self.match(PSParser.R_VERT) pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 631 self.match(PSParser.ML_LEFT) self.state = 632 self.match(PSParser.VERT) self.state = 633 self.expr() self.state = 634 self.match(PSParser.MR_RIGHT) self.state = 635 self.match(PSParser.VERT) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Floor_groupContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Floor_groupContext, self).__init__(parent, invokingState) self.parser = parser def L_FLOOR(self): return self.getToken(PSParser.L_FLOOR, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_FLOOR(self): return self.getToken(PSParser.R_FLOOR, 0) def LL_CORNER(self): return self.getToken(PSParser.LL_CORNER, 0) def LR_CORNER(self): return self.getToken(PSParser.LR_CORNER, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_floor_group def enterRule(self, listener): if hasattr(listener, "enterFloor_group"): listener.enterFloor_group(self) def exitRule(self, listener): if hasattr(listener, "exitFloor_group"): listener.exitFloor_group(self) def floor_group(self): localctx = PSParser.Floor_groupContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_floor_group) try: self.state = 671 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 41, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 639 self.match(PSParser.L_FLOOR) self.state = 640 self.expr() self.state = 641 self.match(PSParser.R_FLOOR) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 643 self.match(PSParser.LL_CORNER) self.state = 644 self.expr() self.state = 645 self.match(PSParser.LR_CORNER) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 647 self.match(PSParser.L_LEFT) self.state = 648 self.match(PSParser.L_FLOOR) self.state = 649 self.expr() self.state = 650 self.match(PSParser.R_RIGHT) self.state = 651 self.match(PSParser.R_FLOOR) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 653 self.match(PSParser.L_LEFT) self.state = 654 self.match(PSParser.LL_CORNER) self.state = 655 self.expr() self.state = 656 self.match(PSParser.R_RIGHT) self.state = 657 self.match(PSParser.LR_CORNER) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 659 self.match(PSParser.ML_LEFT) self.state = 660 self.match(PSParser.L_FLOOR) self.state = 661 self.expr() self.state = 662 self.match(PSParser.MR_RIGHT) self.state = 663 self.match(PSParser.R_FLOOR) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 665 self.match(PSParser.ML_LEFT) self.state = 666 self.match(PSParser.LL_CORNER) self.state = 667 self.expr() self.state = 668 self.match(PSParser.MR_RIGHT) self.state = 669 self.match(PSParser.LR_CORNER) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Ceil_groupContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Ceil_groupContext, self).__init__(parent, invokingState) self.parser = parser def L_CEIL(self): return self.getToken(PSParser.L_CEIL, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_CEIL(self): return self.getToken(PSParser.R_CEIL, 0) def UL_CORNER(self): return self.getToken(PSParser.UL_CORNER, 0) def UR_CORNER(self): return self.getToken(PSParser.UR_CORNER, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def getRuleIndex(self): return PSParser.RULE_ceil_group def enterRule(self, listener): if hasattr(listener, "enterCeil_group"): listener.enterCeil_group(self) def exitRule(self, listener): if hasattr(listener, "exitCeil_group"): listener.exitCeil_group(self) def ceil_group(self): localctx = PSParser.Ceil_groupContext(self, self._ctx, self.state) self.enterRule(localctx, 72, self.RULE_ceil_group) try: self.state = 705 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 42, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 673 self.match(PSParser.L_CEIL) self.state = 674 self.expr() self.state = 675 self.match(PSParser.R_CEIL) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 677 self.match(PSParser.UL_CORNER) self.state = 678 self.expr() self.state = 679 self.match(PSParser.UR_CORNER) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 681 self.match(PSParser.L_LEFT) self.state = 682 self.match(PSParser.L_CEIL) self.state = 683 self.expr() self.state = 684 self.match(PSParser.R_RIGHT) self.state = 685 self.match(PSParser.R_CEIL) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 687 self.match(PSParser.L_LEFT) self.state = 688 self.match(PSParser.UL_CORNER) self.state = 689 self.expr() self.state = 690 self.match(PSParser.R_RIGHT) self.state = 691 self.match(PSParser.UR_CORNER) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 693 self.match(PSParser.ML_LEFT) self.state = 694 self.match(PSParser.L_CEIL) self.state = 695 self.expr() self.state = 696 self.match(PSParser.MR_RIGHT) self.state = 697 self.match(PSParser.R_CEIL) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 699 self.match(PSParser.ML_LEFT) self.state = 700 self.match(PSParser.UL_CORNER) self.state = 701 self.expr() self.state = 702 self.match(PSParser.MR_RIGHT) self.state = 703 self.match(PSParser.UR_CORNER) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AccentContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.AccentContext, self).__init__(parent, invokingState) self.parser = parser self.base = None # ExprContext def accent_symbol(self): return self.getTypedRuleContext(PSParser.Accent_symbolContext, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def getRuleIndex(self): return PSParser.RULE_accent def enterRule(self, listener): if hasattr(listener, "enterAccent"): listener.enterAccent(self) def exitRule(self, listener): if hasattr(listener, "exitAccent"): listener.exitAccent(self) def accent(self): localctx = PSParser.AccentContext(self, self._ctx, self.state) self.enterRule(localctx, 74, self.RULE_accent) try: self.enterOuterAlt(localctx, 1) self.state = 707 self.accent_symbol() self.state = 708 self.match(PSParser.L_BRACE) self.state = 709 localctx.base = self.expr() self.state = 710 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Atom_expr_no_supexprContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Atom_expr_no_supexprContext, self).__init__(parent, invokingState) self.parser = parser def LETTER_NO_E(self): return self.getToken(PSParser.LETTER_NO_E, 0) def GREEK_CMD(self): return self.getToken(PSParser.GREEK_CMD, 0) def OTHER_SYMBOL_CMD(self): return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0) def accent(self): return self.getTypedRuleContext(PSParser.AccentContext, 0) def subexpr(self): return self.getTypedRuleContext(PSParser.SubexprContext, 0) def getRuleIndex(self): return PSParser.RULE_atom_expr_no_supexpr def enterRule(self, listener): if hasattr(listener, "enterAtom_expr_no_supexpr"): listener.enterAtom_expr_no_supexpr(self) def exitRule(self, listener): if hasattr(listener, "exitAtom_expr_no_supexpr"): listener.exitAtom_expr_no_supexpr(self) def atom_expr_no_supexpr(self): localctx = PSParser.Atom_expr_no_supexprContext(self, self._ctx, self.state) self.enterRule(localctx, 76, self.RULE_atom_expr_no_supexpr) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 716 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.LETTER_NO_E]: self.state = 712 self.match(PSParser.LETTER_NO_E) pass elif token in [PSParser.GREEK_CMD]: self.state = 713 self.match(PSParser.GREEK_CMD) pass elif token in [PSParser.OTHER_SYMBOL_CMD]: self.state = 714 self.match(PSParser.OTHER_SYMBOL_CMD) pass elif token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT]: self.state = 715 self.accent() pass else: raise NoViableAltException(self) self.state = 719 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.UNDERSCORE: self.state = 718 self.subexpr() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Atom_exprContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Atom_exprContext, self).__init__(parent, invokingState) self.parser = parser def LETTER_NO_E(self): return self.getToken(PSParser.LETTER_NO_E, 0) def GREEK_CMD(self): return self.getToken(PSParser.GREEK_CMD, 0) def OTHER_SYMBOL_CMD(self): return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0) def accent(self): return self.getTypedRuleContext(PSParser.AccentContext, 0) def supexpr(self): return self.getTypedRuleContext(PSParser.SupexprContext, 0) def subexpr(self): return self.getTypedRuleContext(PSParser.SubexprContext, 0) def getRuleIndex(self): return PSParser.RULE_atom_expr def enterRule(self, listener): if hasattr(listener, "enterAtom_expr"): listener.enterAtom_expr(self) def exitRule(self, listener): if hasattr(listener, "exitAtom_expr"): listener.exitAtom_expr(self) def atom_expr(self): localctx = PSParser.Atom_exprContext(self, self._ctx, self.state) self.enterRule(localctx, 78, self.RULE_atom_expr) try: self.enterOuterAlt(localctx, 1) self.state = 725 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.LETTER_NO_E]: self.state = 721 self.match(PSParser.LETTER_NO_E) pass elif token in [PSParser.GREEK_CMD]: self.state = 722 self.match(PSParser.GREEK_CMD) pass elif token in [PSParser.OTHER_SYMBOL_CMD]: self.state = 723 self.match(PSParser.OTHER_SYMBOL_CMD) pass elif token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT]: self.state = 724 self.accent() pass else: raise NoViableAltException(self) self.state = 735 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 46, self._ctx) if la_ == 1: self.state = 727 self.supexpr() self.state = 728 self.subexpr() elif la_ == 2: self.state = 730 self.subexpr() self.state = 731 self.supexpr() elif la_ == 3: self.state = 733 self.subexpr() elif la_ == 4: self.state = 734 self.supexpr() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class AtomContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.AtomContext, self).__init__(parent, invokingState) self.parser = parser def atom_expr(self): return self.getTypedRuleContext(PSParser.Atom_exprContext, 0) def SYMBOL(self): return self.getToken(PSParser.SYMBOL, 0) def NUMBER(self): return self.getToken(PSParser.NUMBER, 0) def PERCENT_NUMBER(self): return self.getToken(PSParser.PERCENT_NUMBER, 0) def E_NOTATION(self): return self.getToken(PSParser.E_NOTATION, 0) def DIFFERENTIAL(self): return self.getToken(PSParser.DIFFERENTIAL, 0) def mathit(self): return self.getTypedRuleContext(PSParser.MathitContext, 0) def VARIABLE(self): return self.getToken(PSParser.VARIABLE, 0) def getRuleIndex(self): return PSParser.RULE_atom def enterRule(self, listener): if hasattr(listener, "enterAtom"): listener.enterAtom(self) def exitRule(self, listener): if hasattr(listener, "exitAtom"): listener.exitAtom(self) def atom(self): localctx = PSParser.AtomContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_atom) try: self.state = 745 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 47, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 737 self.atom_expr() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 738 self.match(PSParser.SYMBOL) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 739 self.match(PSParser.NUMBER) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 740 self.match(PSParser.PERCENT_NUMBER) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 741 self.match(PSParser.E_NOTATION) pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 742 self.match(PSParser.DIFFERENTIAL) pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 743 self.mathit() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 744 self.match(PSParser.VARIABLE) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class MathitContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.MathitContext, self).__init__(parent, invokingState) self.parser = parser def CMD_MATHIT(self): return self.getToken(PSParser.CMD_MATHIT, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def mathit_text(self): return self.getTypedRuleContext(PSParser.Mathit_textContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def getRuleIndex(self): return PSParser.RULE_mathit def enterRule(self, listener): if hasattr(listener, "enterMathit"): listener.enterMathit(self) def exitRule(self, listener): if hasattr(listener, "exitMathit"): listener.exitMathit(self) def mathit(self): localctx = PSParser.MathitContext(self, self._ctx, self.state) self.enterRule(localctx, 82, self.RULE_mathit) try: self.enterOuterAlt(localctx, 1) self.state = 747 self.match(PSParser.CMD_MATHIT) self.state = 748 self.match(PSParser.L_BRACE) self.state = 749 self.mathit_text() self.state = 750 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Mathit_textContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Mathit_textContext, self).__init__(parent, invokingState) self.parser = parser def LETTER_NO_E(self, i=None): if i is None: return self.getTokens(PSParser.LETTER_NO_E) else: return self.getToken(PSParser.LETTER_NO_E, i) def E_NOTATION_E(self, i=None): if i is None: return self.getTokens(PSParser.E_NOTATION_E) else: return self.getToken(PSParser.E_NOTATION_E, i) def EXP_E(self, i=None): if i is None: return self.getTokens(PSParser.EXP_E) else: return self.getToken(PSParser.EXP_E, i) def getRuleIndex(self): return PSParser.RULE_mathit_text def enterRule(self, listener): if hasattr(listener, "enterMathit_text"): listener.enterMathit_text(self) def exitRule(self, listener): if hasattr(listener, "exitMathit_text"): listener.exitMathit_text(self) def mathit_text(self): localctx = PSParser.Mathit_textContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_mathit_text) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 753 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 752 _la = self._input.LA(1) if not(((((_la - 174)) & ~0x3f) == 0 and ((1 << (_la - 174)) & ((1 << (PSParser.EXP_E - 174)) | (1 << (PSParser.E_NOTATION_E - 174)) | (1 << (PSParser.LETTER_NO_E - 174)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 755 self._errHandler.sync(self) _la = self._input.LA(1) if not (((((_la - 174)) & ~0x3f) == 0 and ((1 << (_la - 174)) & ((1 << (PSParser.EXP_E - 174)) | (1 << (PSParser.E_NOTATION_E - 174)) | (1 << (PSParser.LETTER_NO_E - 174)))) != 0)): break except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class FracContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.FracContext, self).__init__(parent, invokingState) self.parser = parser self.upper = None # ExprContext self.lower = None # ExprContext def CMD_FRAC(self): return self.getToken(PSParser.CMD_FRAC, 0) def L_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.L_BRACE) else: return self.getToken(PSParser.L_BRACE, i) def R_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.R_BRACE) else: return self.getToken(PSParser.R_BRACE, i) def expr(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.ExprContext) else: return self.getTypedRuleContext(PSParser.ExprContext, i) def getRuleIndex(self): return PSParser.RULE_frac def enterRule(self, listener): if hasattr(listener, "enterFrac"): listener.enterFrac(self) def exitRule(self, listener): if hasattr(listener, "exitFrac"): listener.exitFrac(self) def frac(self): localctx = PSParser.FracContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_frac) try: self.enterOuterAlt(localctx, 1) self.state = 757 self.match(PSParser.CMD_FRAC) self.state = 758 self.match(PSParser.L_BRACE) self.state = 759 localctx.upper = self.expr() self.state = 760 self.match(PSParser.R_BRACE) self.state = 761 self.match(PSParser.L_BRACE) self.state = 762 localctx.lower = self.expr() self.state = 763 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class BinomContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.BinomContext, self).__init__(parent, invokingState) self.parser = parser self.upper = None # ExprContext self.lower = None # ExprContext def L_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.L_BRACE) else: return self.getToken(PSParser.L_BRACE, i) def CMD_CHOOSE(self): return self.getToken(PSParser.CMD_CHOOSE, 0) def R_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.R_BRACE) else: return self.getToken(PSParser.R_BRACE, i) def expr(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.ExprContext) else: return self.getTypedRuleContext(PSParser.ExprContext, i) def CMD_BINOM(self): return self.getToken(PSParser.CMD_BINOM, 0) def getRuleIndex(self): return PSParser.RULE_binom def enterRule(self, listener): if hasattr(listener, "enterBinom"): listener.enterBinom(self) def exitRule(self, listener): if hasattr(listener, "exitBinom"): listener.exitBinom(self) def binom(self): localctx = PSParser.BinomContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_binom) try: self.state = 779 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.L_BRACE]: self.enterOuterAlt(localctx, 1) self.state = 765 self.match(PSParser.L_BRACE) self.state = 766 localctx.upper = self.expr() self.state = 767 self.match(PSParser.CMD_CHOOSE) self.state = 768 localctx.lower = self.expr() self.state = 769 self.match(PSParser.R_BRACE) pass elif token in [PSParser.CMD_BINOM]: self.enterOuterAlt(localctx, 2) self.state = 771 self.match(PSParser.CMD_BINOM) self.state = 772 self.match(PSParser.L_BRACE) self.state = 773 localctx.upper = self.expr() self.state = 774 self.match(PSParser.R_BRACE) self.state = 775 self.match(PSParser.L_BRACE) self.state = 776 localctx.lower = self.expr() self.state = 777 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_normal_functions_single_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_normal_functions_single_argContext, self).__init__(parent, invokingState) self.parser = parser def FUNC_LOG(self): return self.getToken(PSParser.FUNC_LOG, 0) def FUNC_LN(self): return self.getToken(PSParser.FUNC_LN, 0) def FUNC_EXP(self): return self.getToken(PSParser.FUNC_EXP, 0) def FUNC_SIN(self): return self.getToken(PSParser.FUNC_SIN, 0) def FUNC_COS(self): return self.getToken(PSParser.FUNC_COS, 0) def FUNC_TAN(self): return self.getToken(PSParser.FUNC_TAN, 0) def FUNC_CSC(self): return self.getToken(PSParser.FUNC_CSC, 0) def FUNC_SEC(self): return self.getToken(PSParser.FUNC_SEC, 0) def FUNC_COT(self): return self.getToken(PSParser.FUNC_COT, 0) def FUNC_ARCSIN(self): return self.getToken(PSParser.FUNC_ARCSIN, 0) def FUNC_ARCCOS(self): return self.getToken(PSParser.FUNC_ARCCOS, 0) def FUNC_ARCTAN(self): return self.getToken(PSParser.FUNC_ARCTAN, 0) def FUNC_ARCCSC(self): return self.getToken(PSParser.FUNC_ARCCSC, 0) def FUNC_ARCSEC(self): return self.getToken(PSParser.FUNC_ARCSEC, 0) def FUNC_ARCCOT(self): return self.getToken(PSParser.FUNC_ARCCOT, 0) def FUNC_SINH(self): return self.getToken(PSParser.FUNC_SINH, 0) def FUNC_COSH(self): return self.getToken(PSParser.FUNC_COSH, 0) def FUNC_TANH(self): return self.getToken(PSParser.FUNC_TANH, 0) def FUNC_ARSINH(self): return self.getToken(PSParser.FUNC_ARSINH, 0) def FUNC_ARCOSH(self): return self.getToken(PSParser.FUNC_ARCOSH, 0) def FUNC_ARTANH(self): return self.getToken(PSParser.FUNC_ARTANH, 0) def FUNC_ARCSINH(self): return self.getToken(PSParser.FUNC_ARCSINH, 0) def FUNC_ARCCOSH(self): return self.getToken(PSParser.FUNC_ARCCOSH, 0) def FUNC_ARCTANH(self): return self.getToken(PSParser.FUNC_ARCTANH, 0) def FUNC_FLOOR(self): return self.getToken(PSParser.FUNC_FLOOR, 0) def FUNC_CEIL(self): return self.getToken(PSParser.FUNC_CEIL, 0) def FUNC_DET(self): return self.getToken(PSParser.FUNC_DET, 0) def getRuleIndex(self): return PSParser.RULE_func_normal_functions_single_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_normal_functions_single_arg"): listener.enterFunc_normal_functions_single_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_normal_functions_single_arg"): listener.exitFunc_normal_functions_single_arg(self) def func_normal_functions_single_arg(self): localctx = PSParser.Func_normal_functions_single_argContext(self, self._ctx, self.state) self.enterRule(localctx, 90, self.RULE_func_normal_functions_single_arg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 781 _la = self._input.LA(1) if not(((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (PSParser.FUNC_LOG - 87)) | (1 << (PSParser.FUNC_LN - 87)) | (1 << (PSParser.FUNC_EXP - 87)) | (1 << (PSParser.FUNC_SIN - 87)) | (1 << (PSParser.FUNC_COS - 87)) | (1 << (PSParser.FUNC_TAN - 87)) | (1 << (PSParser.FUNC_CSC - 87)) | (1 << (PSParser.FUNC_SEC - 87)) | (1 << (PSParser.FUNC_COT - 87)) | (1 << (PSParser.FUNC_ARCSIN - 87)) | (1 << (PSParser.FUNC_ARCCOS - 87)) | (1 << (PSParser.FUNC_ARCTAN - 87)) | (1 << (PSParser.FUNC_ARCCSC - 87)) | (1 << (PSParser.FUNC_ARCSEC - 87)) | (1 << (PSParser.FUNC_ARCCOT - 87)) | (1 << (PSParser.FUNC_SINH - 87)) | (1 << (PSParser.FUNC_COSH - 87)) | (1 << (PSParser.FUNC_TANH - 87)) | (1 << (PSParser.FUNC_ARSINH - 87)) | (1 << (PSParser.FUNC_ARCOSH - 87)) | (1 << (PSParser.FUNC_ARTANH - 87)) | (1 << (PSParser.FUNC_ARCSINH - 87)) | (1 << (PSParser.FUNC_ARCCOSH - 87)) | (1 << (PSParser.FUNC_ARCTANH - 87)) | (1 << (PSParser.FUNC_FLOOR - 87)) | (1 << (PSParser.FUNC_CEIL - 87)) | (1 << (PSParser.FUNC_DET - 87)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_normal_functions_multi_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_normal_functions_multi_argContext, self).__init__(parent, invokingState) self.parser = parser def FUNC_GCD(self): return self.getToken(PSParser.FUNC_GCD, 0) def FUNC_LCM(self): return self.getToken(PSParser.FUNC_LCM, 0) def FUNC_MAX(self): return self.getToken(PSParser.FUNC_MAX, 0) def FUNC_MIN(self): return self.getToken(PSParser.FUNC_MIN, 0) def getRuleIndex(self): return PSParser.RULE_func_normal_functions_multi_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_normal_functions_multi_arg"): listener.enterFunc_normal_functions_multi_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_normal_functions_multi_arg"): listener.exitFunc_normal_functions_multi_arg(self) def func_normal_functions_multi_arg(self): localctx = PSParser.Func_normal_functions_multi_argContext(self, self._ctx, self.state) self.enterRule(localctx, 92, self.RULE_func_normal_functions_multi_arg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 783 _la = self._input.LA(1) if not(((((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & ((1 << (PSParser.FUNC_GCD - 122)) | (1 << (PSParser.FUNC_LCM - 122)) | (1 << (PSParser.FUNC_MAX - 122)) | (1 << (PSParser.FUNC_MIN - 122)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_operator_names_single_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_operator_names_single_argContext, self).__init__(parent, invokingState) self.parser = parser def FUNC_ARSINH_NAME(self): return self.getToken(PSParser.FUNC_ARSINH_NAME, 0) def FUNC_ARCOSH_NAME(self): return self.getToken(PSParser.FUNC_ARCOSH_NAME, 0) def FUNC_ARTANH_NAME(self): return self.getToken(PSParser.FUNC_ARTANH_NAME, 0) def FUNC_ARCSINH_NAME(self): return self.getToken(PSParser.FUNC_ARCSINH_NAME, 0) def FUNC_ARCCOSH_NAME(self): return self.getToken(PSParser.FUNC_ARCCOSH_NAME, 0) def FUNC_ARCTANH_NAME(self): return self.getToken(PSParser.FUNC_ARCTANH_NAME, 0) def FUNC_FLOOR_NAME(self): return self.getToken(PSParser.FUNC_FLOOR_NAME, 0) def FUNC_CEIL_NAME(self): return self.getToken(PSParser.FUNC_CEIL_NAME, 0) def FUNC_EYE_NAME(self): return self.getToken(PSParser.FUNC_EYE_NAME, 0) def FUNC_RANK_NAME(self): return self.getToken(PSParser.FUNC_RANK_NAME, 0) def FUNC_TRACE_NAME(self): return self.getToken(PSParser.FUNC_TRACE_NAME, 0) def FUNC_RREF_NAME(self): return self.getToken(PSParser.FUNC_RREF_NAME, 0) def FUNC_NULLSPACE_NAME(self): return self.getToken(PSParser.FUNC_NULLSPACE_NAME, 0) def FUNC_DIAGONALIZE_NAME(self): return self.getToken(PSParser.FUNC_DIAGONALIZE_NAME, 0) def FUNC_NORM_NAME(self): return self.getToken(PSParser.FUNC_NORM_NAME, 0) def FUNC_EIGENVALS_NAME(self): return self.getToken(PSParser.FUNC_EIGENVALS_NAME, 0) def FUNC_EIGENVECTORS_NAME(self): return self.getToken(PSParser.FUNC_EIGENVECTORS_NAME, 0) def FUNC_SVD_NAME(self): return self.getToken(PSParser.FUNC_SVD_NAME, 0) def FUNC_COLS_NAME(self): return self.getToken(PSParser.FUNC_COLS_NAME, 0) def FUNC_ROWS_NAME(self): return self.getToken(PSParser.FUNC_ROWS_NAME, 0) def getRuleIndex(self): return PSParser.RULE_func_operator_names_single_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_operator_names_single_arg"): listener.enterFunc_operator_names_single_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_operator_names_single_arg"): listener.exitFunc_operator_names_single_arg(self) def func_operator_names_single_arg(self): localctx = PSParser.Func_operator_names_single_argContext(self, self._ctx, self.state) self.enterRule(localctx, 94, self.RULE_func_operator_names_single_arg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 785 _la = self._input.LA(1) if not(((((_la - 111)) & ~0x3f) == 0 and ((1 << (_la - 111)) & ((1 << (PSParser.FUNC_ARSINH_NAME - 111)) | (1 << (PSParser.FUNC_ARCSINH_NAME - 111)) | (1 << (PSParser.FUNC_ARCOSH_NAME - 111)) | (1 << (PSParser.FUNC_ARCCOSH_NAME - 111)) | (1 << (PSParser.FUNC_ARTANH_NAME - 111)) | (1 << (PSParser.FUNC_ARCTANH_NAME - 111)) | (1 << (PSParser.FUNC_FLOOR_NAME - 111)) | (1 << (PSParser.FUNC_CEIL_NAME - 111)) | (1 << (PSParser.FUNC_EYE_NAME - 111)) | (1 << (PSParser.FUNC_COLS_NAME - 111)) | (1 << (PSParser.FUNC_ROWS_NAME - 111)) | (1 << (PSParser.FUNC_NORM_NAME - 111)) | (1 << (PSParser.FUNC_RANK_NAME - 111)) | (1 << (PSParser.FUNC_TRACE_NAME - 111)) | (1 << (PSParser.FUNC_RREF_NAME - 111)) | (1 << (PSParser.FUNC_NULLSPACE_NAME - 111)) | (1 << (PSParser.FUNC_DIAGONALIZE_NAME - 111)) | (1 << (PSParser.FUNC_EIGENVALS_NAME - 111)) | (1 << (PSParser.FUNC_EIGENVECTORS_NAME - 111)) | (1 << (PSParser.FUNC_SVD_NAME - 111)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_operator_names_multi_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_operator_names_multi_argContext, self).__init__(parent, invokingState) self.parser = parser def FUNC_GCD_NAME(self): return self.getToken(PSParser.FUNC_GCD_NAME, 0) def FUNC_LCM_NAME(self): return self.getToken(PSParser.FUNC_LCM_NAME, 0) def FUNC_ZEROS_NAME(self): return self.getToken(PSParser.FUNC_ZEROS_NAME, 0) def FUNC_ORTHOGONALIZE_NAME(self): return self.getToken(PSParser.FUNC_ORTHOGONALIZE_NAME, 0) def FUNC_ONES_NAME(self): return self.getToken(PSParser.FUNC_ONES_NAME, 0) def FUNC_DIAG_NAME(self): return self.getToken(PSParser.FUNC_DIAG_NAME, 0) def FUNC_HSTACK_NAME(self): return self.getToken(PSParser.FUNC_HSTACK_NAME, 0) def FUNC_VSTACK_NAME(self): return self.getToken(PSParser.FUNC_VSTACK_NAME, 0) def getRuleIndex(self): return PSParser.RULE_func_operator_names_multi_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_operator_names_multi_arg"): listener.enterFunc_operator_names_multi_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_operator_names_multi_arg"): listener.exitFunc_operator_names_multi_arg(self) def func_operator_names_multi_arg(self): localctx = PSParser.Func_operator_names_multi_argContext(self, self._ctx, self.state) self.enterRule(localctx, 96, self.RULE_func_operator_names_multi_arg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 787 _la = self._input.LA(1) if not(((((_la - 117)) & ~0x3f) == 0 and ((1 << (_la - 117)) & ((1 << (PSParser.FUNC_GCD_NAME - 117)) | (1 << (PSParser.FUNC_LCM_NAME - 117)) | (1 << (PSParser.FUNC_ZEROS_NAME - 117)) | (1 << (PSParser.FUNC_ONES_NAME - 117)) | (1 << (PSParser.FUNC_DIAG_NAME - 117)) | (1 << (PSParser.FUNC_HSTACK_NAME - 117)) | (1 << (PSParser.FUNC_VSTACK_NAME - 117)) | (1 << (PSParser.FUNC_ORTHOGONALIZE_NAME - 117)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_normal_single_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_normal_single_argContext, self).__init__(parent, invokingState) self.parser = parser self.func_operator_name = None # Func_operator_names_single_argContext def func_normal_functions_single_arg(self): return self.getTypedRuleContext(PSParser.Func_normal_functions_single_argContext, 0) def CMD_OPERATORNAME(self): return self.getToken(PSParser.CMD_OPERATORNAME, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def func_operator_names_single_arg(self): return self.getTypedRuleContext(PSParser.Func_operator_names_single_argContext, 0) def getRuleIndex(self): return PSParser.RULE_func_normal_single_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_normal_single_arg"): listener.enterFunc_normal_single_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_normal_single_arg"): listener.exitFunc_normal_single_arg(self) def func_normal_single_arg(self): localctx = PSParser.Func_normal_single_argContext(self, self._ctx, self.state) self.enterRule(localctx, 98, self.RULE_func_normal_single_arg) try: self.state = 795 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.FUNC_LOG, PSParser.FUNC_LN, PSParser.FUNC_EXP, PSParser.FUNC_SIN, PSParser.FUNC_COS, PSParser.FUNC_TAN, PSParser.FUNC_CSC, PSParser.FUNC_SEC, PSParser.FUNC_COT, PSParser.FUNC_ARCSIN, PSParser.FUNC_ARCCOS, PSParser.FUNC_ARCTAN, PSParser.FUNC_ARCCSC, PSParser.FUNC_ARCSEC, PSParser.FUNC_ARCCOT, PSParser.FUNC_SINH, PSParser.FUNC_COSH, PSParser.FUNC_TANH, PSParser.FUNC_ARSINH, PSParser.FUNC_ARCOSH, PSParser.FUNC_ARTANH, PSParser.FUNC_ARCSINH, PSParser.FUNC_ARCCOSH, PSParser.FUNC_ARCTANH, PSParser.FUNC_FLOOR, PSParser.FUNC_CEIL, PSParser.FUNC_DET]: self.enterOuterAlt(localctx, 1) self.state = 789 self.func_normal_functions_single_arg() pass elif token in [PSParser.CMD_OPERATORNAME]: self.enterOuterAlt(localctx, 2) self.state = 790 self.match(PSParser.CMD_OPERATORNAME) self.state = 791 self.match(PSParser.L_BRACE) self.state = 792 localctx.func_operator_name = self.func_operator_names_single_arg() self.state = 793 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_normal_multi_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_normal_multi_argContext, self).__init__(parent, invokingState) self.parser = parser self.func_operator_name = None # Func_operator_names_multi_argContext def func_normal_functions_multi_arg(self): return self.getTypedRuleContext(PSParser.Func_normal_functions_multi_argContext, 0) def CMD_OPERATORNAME(self): return self.getToken(PSParser.CMD_OPERATORNAME, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def func_operator_names_multi_arg(self): return self.getTypedRuleContext(PSParser.Func_operator_names_multi_argContext, 0) def getRuleIndex(self): return PSParser.RULE_func_normal_multi_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_normal_multi_arg"): listener.enterFunc_normal_multi_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_normal_multi_arg"): listener.exitFunc_normal_multi_arg(self) def func_normal_multi_arg(self): localctx = PSParser.Func_normal_multi_argContext(self, self._ctx, self.state) self.enterRule(localctx, 100, self.RULE_func_normal_multi_arg) try: self.state = 803 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.FUNC_GCD, PSParser.FUNC_LCM, PSParser.FUNC_MAX, PSParser.FUNC_MIN]: self.enterOuterAlt(localctx, 1) self.state = 797 self.func_normal_functions_multi_arg() pass elif token in [PSParser.CMD_OPERATORNAME]: self.enterOuterAlt(localctx, 2) self.state = 798 self.match(PSParser.CMD_OPERATORNAME) self.state = 799 self.match(PSParser.L_BRACE) self.state = 800 localctx.func_operator_name = self.func_operator_names_multi_arg() self.state = 801 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class FuncContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.FuncContext, self).__init__(parent, invokingState) self.parser = parser self.root = None # ExprContext self.base = None # ExprContext def func_normal_single_arg(self): return self.getTypedRuleContext(PSParser.Func_normal_single_argContext, 0) def L_PAREN(self): return self.getToken(PSParser.L_PAREN, 0) def func_single_arg(self): return self.getTypedRuleContext(PSParser.Func_single_argContext, 0) def R_PAREN(self): return self.getToken(PSParser.R_PAREN, 0) def func_single_arg_noparens(self): return self.getTypedRuleContext(PSParser.Func_single_arg_noparensContext, 0) def subexpr(self): return self.getTypedRuleContext(PSParser.SubexprContext, 0) def supexpr(self): return self.getTypedRuleContext(PSParser.SupexprContext, 0) def L_LEFT(self): return self.getToken(PSParser.L_LEFT, 0) def R_RIGHT(self): return self.getToken(PSParser.R_RIGHT, 0) def ML_LEFT(self): return self.getToken(PSParser.ML_LEFT, 0) def MR_RIGHT(self): return self.getToken(PSParser.MR_RIGHT, 0) def func_normal_multi_arg(self): return self.getTypedRuleContext(PSParser.Func_normal_multi_argContext, 0) def func_multi_arg(self): return self.getTypedRuleContext(PSParser.Func_multi_argContext, 0) def func_multi_arg_noparens(self): return self.getTypedRuleContext(PSParser.Func_multi_arg_noparensContext, 0) def atom_expr_no_supexpr(self): return self.getTypedRuleContext(PSParser.Atom_expr_no_supexprContext, 0) def func_common_args(self): return self.getTypedRuleContext(PSParser.Func_common_argsContext, 0) def L_BRACKET(self): return self.getToken(PSParser.L_BRACKET, 0) def R_BRACKET(self): return self.getToken(PSParser.R_BRACKET, 0) def L_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.L_BRACE) else: return self.getToken(PSParser.L_BRACE, i) def R_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.R_BRACE) else: return self.getToken(PSParser.R_BRACE, i) def FUNC_INT(self): return self.getToken(PSParser.FUNC_INT, 0) def DIFFERENTIAL(self): return self.getToken(PSParser.DIFFERENTIAL, 0) def frac(self): return self.getTypedRuleContext(PSParser.FracContext, 0) def additive(self): return self.getTypedRuleContext(PSParser.AdditiveContext, 0) def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def CARET(self): return self.getToken(PSParser.CARET, 0) def FUNC_SQRT(self): return self.getToken(PSParser.FUNC_SQRT, 0) def expr(self, i=None): if i is None: return self.getTypedRuleContexts(PSParser.ExprContext) else: return self.getTypedRuleContext(PSParser.ExprContext, i) def mp(self): return self.getTypedRuleContext(PSParser.MpContext, 0) def FUNC_SUM(self): return self.getToken(PSParser.FUNC_SUM, 0) def FUNC_PROD(self): return self.getToken(PSParser.FUNC_PROD, 0) def subeq(self): return self.getTypedRuleContext(PSParser.SubeqContext, 0) def FUNC_LIM(self): return self.getToken(PSParser.FUNC_LIM, 0) def limit_sub(self): return self.getTypedRuleContext(PSParser.Limit_subContext, 0) def EXP_E(self): return self.getToken(PSParser.EXP_E, 0) def getRuleIndex(self): return PSParser.RULE_func def enterRule(self, listener): if hasattr(listener, "enterFunc"): listener.enterFunc(self) def exitRule(self, listener): if hasattr(listener, "exitFunc"): listener.exitFunc(self) def func(self): localctx = PSParser.FuncContext(self, self._ctx, self.state) self.enterRule(localctx, 102, self.RULE_func) self._la = 0 # Token type try: self.state = 971 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 84, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 805 self.func_normal_single_arg() self.state = 818 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 56, self._ctx) if la_ == 1: self.state = 807 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.UNDERSCORE: self.state = 806 self.subexpr() self.state = 810 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 809 self.supexpr() pass elif la_ == 2: self.state = 813 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 812 self.supexpr() self.state = 816 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.UNDERSCORE: self.state = 815 self.subexpr() pass self.state = 841 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 61, self._ctx) if la_ == 1: self.state = 821 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_LEFT: self.state = 820 self.match(PSParser.L_LEFT) self.state = 823 self.match(PSParser.L_PAREN) self.state = 824 self.func_single_arg() self.state = 826 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.R_RIGHT: self.state = 825 self.match(PSParser.R_RIGHT) self.state = 828 self.match(PSParser.R_PAREN) pass elif la_ == 2: self.state = 831 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.ML_LEFT: self.state = 830 self.match(PSParser.ML_LEFT) self.state = 833 self.match(PSParser.L_PAREN) self.state = 834 self.func_single_arg() self.state = 836 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.MR_RIGHT: self.state = 835 self.match(PSParser.MR_RIGHT) self.state = 838 self.match(PSParser.R_PAREN) pass elif la_ == 3: self.state = 840 self.func_single_arg_noparens() pass pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 843 self.func_normal_multi_arg() self.state = 856 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 66, self._ctx) if la_ == 1: self.state = 845 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.UNDERSCORE: self.state = 844 self.subexpr() self.state = 848 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 847 self.supexpr() pass elif la_ == 2: self.state = 851 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 850 self.supexpr() self.state = 854 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.UNDERSCORE: self.state = 853 self.subexpr() pass self.state = 879 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 71, self._ctx) if la_ == 1: self.state = 859 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_LEFT: self.state = 858 self.match(PSParser.L_LEFT) self.state = 861 self.match(PSParser.L_PAREN) self.state = 862 self.func_multi_arg() self.state = 864 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.R_RIGHT: self.state = 863 self.match(PSParser.R_RIGHT) self.state = 866 self.match(PSParser.R_PAREN) pass elif la_ == 2: self.state = 869 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.ML_LEFT: self.state = 868 self.match(PSParser.ML_LEFT) self.state = 871 self.match(PSParser.L_PAREN) self.state = 872 self.func_multi_arg() self.state = 874 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.MR_RIGHT: self.state = 873 self.match(PSParser.MR_RIGHT) self.state = 876 self.match(PSParser.R_PAREN) pass elif la_ == 3: self.state = 878 self.func_multi_arg_noparens() pass pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 881 self.atom_expr_no_supexpr() self.state = 883 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 882 self.supexpr() self.state = 886 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_LEFT: self.state = 885 self.match(PSParser.L_LEFT) self.state = 888 _la = self._input.LA(1) if not(_la == PSParser.L_PAREN or _la == PSParser.L_BRACKET): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 889 self.func_common_args() self.state = 890 _la = self._input.LA(1) if not(_la == PSParser.R_PAREN or _la == PSParser.R_BRACKET): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 892 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 74, self._ctx) if la_ == 1: self.state = 891 self.match(PSParser.R_RIGHT) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 894 self.atom_expr_no_supexpr() self.state = 896 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 895 self.supexpr() self.state = 898 self.match(PSParser.L_BRACE) self.state = 900 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_LEFT: self.state = 899 self.match(PSParser.L_LEFT) self.state = 902 _la = self._input.LA(1) if not(_la == PSParser.L_PAREN or _la == PSParser.L_BRACKET): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 903 self.func_common_args() self.state = 904 _la = self._input.LA(1) if not(_la == PSParser.R_PAREN or _la == PSParser.R_BRACKET): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 906 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.R_RIGHT: self.state = 905 self.match(PSParser.R_RIGHT) self.state = 908 self.match(PSParser.R_BRACE) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) self.state = 910 self.match(PSParser.FUNC_INT) self.state = 931 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 78, self._ctx) if la_ == 1: self.state = 911 self.subexpr() self.state = 912 self.supexpr() elif la_ == 2: self.state = 914 self.supexpr() self.state = 915 self.subexpr() elif la_ == 3: self.state = 917 self.match(PSParser.UNDERSCORE) self.state = 918 self.match(PSParser.L_BRACE) self.state = 919 self.match(PSParser.R_BRACE) self.state = 921 self.match(PSParser.CARET) self.state = 922 self.match(PSParser.L_BRACE) self.state = 923 self.match(PSParser.R_BRACE) elif la_ == 4: self.state = 924 self.match(PSParser.CARET) self.state = 925 self.match(PSParser.L_BRACE) self.state = 926 self.match(PSParser.R_BRACE) self.state = 928 self.match(PSParser.UNDERSCORE) self.state = 929 self.match(PSParser.L_BRACE) self.state = 930 self.match(PSParser.R_BRACE) self.state = 939 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 80, self._ctx) if la_ == 1: self.state = 934 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 79, self._ctx) if la_ == 1: self.state = 933 self.additive(0) self.state = 936 self.match(PSParser.DIFFERENTIAL) pass elif la_ == 2: self.state = 937 self.frac() pass elif la_ == 3: self.state = 938 self.additive(0) pass pass elif la_ == 6: self.enterOuterAlt(localctx, 6) self.state = 941 self.match(PSParser.FUNC_SQRT) self.state = 946 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.L_BRACKET: self.state = 942 self.match(PSParser.L_BRACKET) self.state = 943 localctx.root = self.expr() self.state = 944 self.match(PSParser.R_BRACKET) self.state = 948 self.match(PSParser.L_BRACE) self.state = 949 localctx.base = self.expr() self.state = 950 self.match(PSParser.R_BRACE) pass elif la_ == 7: self.enterOuterAlt(localctx, 7) self.state = 952 _la = self._input.LA(1) if not(_la == PSParser.FUNC_SUM or _la == PSParser.FUNC_PROD): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 959 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.UNDERSCORE]: self.state = 953 self.subeq() self.state = 954 self.supexpr() pass elif token in [PSParser.CARET]: self.state = 956 self.supexpr() self.state = 957 self.subeq() pass else: raise NoViableAltException(self) self.state = 961 self.mp(0) pass elif la_ == 8: self.enterOuterAlt(localctx, 8) self.state = 963 self.match(PSParser.FUNC_LIM) self.state = 964 self.limit_sub() self.state = 965 self.mp(0) pass elif la_ == 9: self.enterOuterAlt(localctx, 9) self.state = 967 self.match(PSParser.EXP_E) self.state = 969 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 83, self._ctx) if la_ == 1: self.state = 968 self.supexpr() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ArgsContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.ArgsContext, self).__init__(parent, invokingState) self.parser = parser def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def COMMA(self): return self.getToken(PSParser.COMMA, 0) def args(self): return self.getTypedRuleContext(PSParser.ArgsContext, 0) def getRuleIndex(self): return PSParser.RULE_args def enterRule(self, listener): if hasattr(listener, "enterArgs"): listener.enterArgs(self) def exitRule(self, listener): if hasattr(listener, "exitArgs"): listener.exitArgs(self) def args(self): localctx = PSParser.ArgsContext(self, self._ctx, self.state) self.enterRule(localctx, 104, self.RULE_args) try: self.state = 978 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 85, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 973 self.expr() self.state = 974 self.match(PSParser.COMMA) self.state = 975 self.args() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 977 self.expr() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_common_argsContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_common_argsContext, self).__init__(parent, invokingState) self.parser = parser def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def COMMA(self): return self.getToken(PSParser.COMMA, 0) def args(self): return self.getTypedRuleContext(PSParser.ArgsContext, 0) def getRuleIndex(self): return PSParser.RULE_func_common_args def enterRule(self, listener): if hasattr(listener, "enterFunc_common_args"): listener.enterFunc_common_args(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_common_args"): listener.exitFunc_common_args(self) def func_common_args(self): localctx = PSParser.Func_common_argsContext(self, self._ctx, self.state) self.enterRule(localctx, 106, self.RULE_func_common_args) try: self.state = 988 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 86, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 980 self.atom() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 981 self.expr() self.state = 982 self.match(PSParser.COMMA) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) self.state = 984 self.expr() self.state = 985 self.match(PSParser.COMMA) self.state = 986 self.args() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Limit_subContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Limit_subContext, self).__init__(parent, invokingState) self.parser = parser def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def L_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.L_BRACE) else: return self.getToken(PSParser.L_BRACE, i) def LIM_APPROACH_SYM(self): return self.getToken(PSParser.LIM_APPROACH_SYM, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_BRACE(self, i=None): if i is None: return self.getTokens(PSParser.R_BRACE) else: return self.getToken(PSParser.R_BRACE, i) def LETTER_NO_E(self): return self.getToken(PSParser.LETTER_NO_E, 0) def GREEK_CMD(self): return self.getToken(PSParser.GREEK_CMD, 0) def OTHER_SYMBOL_CMD(self): return self.getToken(PSParser.OTHER_SYMBOL_CMD, 0) def CARET(self): return self.getToken(PSParser.CARET, 0) def ADD(self): return self.getToken(PSParser.ADD, 0) def SUB(self): return self.getToken(PSParser.SUB, 0) def getRuleIndex(self): return PSParser.RULE_limit_sub def enterRule(self, listener): if hasattr(listener, "enterLimit_sub"): listener.enterLimit_sub(self) def exitRule(self, listener): if hasattr(listener, "exitLimit_sub"): listener.exitLimit_sub(self) def limit_sub(self): localctx = PSParser.Limit_subContext(self, self._ctx, self.state) self.enterRule(localctx, 108, self.RULE_limit_sub) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 990 self.match(PSParser.UNDERSCORE) self.state = 991 self.match(PSParser.L_BRACE) self.state = 992 _la = self._input.LA(1) if not(((((_la - 176)) & ~0x3f) == 0 and ((1 << (_la - 176)) & ((1 << (PSParser.LETTER_NO_E - 176)) | (1 << (PSParser.GREEK_CMD - 176)) | (1 << (PSParser.OTHER_SYMBOL_CMD - 176)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 993 self.match(PSParser.LIM_APPROACH_SYM) self.state = 994 self.expr() self.state = 999 self._errHandler.sync(self) _la = self._input.LA(1) if _la == PSParser.CARET: self.state = 995 self.match(PSParser.CARET) self.state = 996 self.match(PSParser.L_BRACE) self.state = 997 _la = self._input.LA(1) if not(_la == PSParser.ADD or _la == PSParser.SUB): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 998 self.match(PSParser.R_BRACE) self.state = 1001 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_single_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_single_argContext, self).__init__(parent, invokingState) self.parser = parser def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def getRuleIndex(self): return PSParser.RULE_func_single_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_single_arg"): listener.enterFunc_single_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_single_arg"): listener.exitFunc_single_arg(self) def func_single_arg(self): localctx = PSParser.Func_single_argContext(self, self._ctx, self.state) self.enterRule(localctx, 110, self.RULE_func_single_arg) try: self.enterOuterAlt(localctx, 1) self.state = 1003 self.expr() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_single_arg_noparensContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_single_arg_noparensContext, self).__init__(parent, invokingState) self.parser = parser def mp_nofunc(self): return self.getTypedRuleContext(PSParser.Mp_nofuncContext, 0) def getRuleIndex(self): return PSParser.RULE_func_single_arg_noparens def enterRule(self, listener): if hasattr(listener, "enterFunc_single_arg_noparens"): listener.enterFunc_single_arg_noparens(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_single_arg_noparens"): listener.exitFunc_single_arg_noparens(self) def func_single_arg_noparens(self): localctx = PSParser.Func_single_arg_noparensContext(self, self._ctx, self.state) self.enterRule(localctx, 112, self.RULE_func_single_arg_noparens) try: self.enterOuterAlt(localctx, 1) self.state = 1005 self.mp_nofunc(0) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_multi_argContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_multi_argContext, self).__init__(parent, invokingState) self.parser = parser def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def COMMA(self): return self.getToken(PSParser.COMMA, 0) def func_multi_arg(self): return self.getTypedRuleContext(PSParser.Func_multi_argContext, 0) def getRuleIndex(self): return PSParser.RULE_func_multi_arg def enterRule(self, listener): if hasattr(listener, "enterFunc_multi_arg"): listener.enterFunc_multi_arg(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_multi_arg"): listener.exitFunc_multi_arg(self) def func_multi_arg(self): localctx = PSParser.Func_multi_argContext(self, self._ctx, self.state) self.enterRule(localctx, 114, self.RULE_func_multi_arg) try: self.state = 1012 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 88, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 1007 self.expr() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 1008 self.expr() self.state = 1009 self.match(PSParser.COMMA) self.state = 1010 self.func_multi_arg() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class Func_multi_arg_noparensContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.Func_multi_arg_noparensContext, self).__init__(parent, invokingState) self.parser = parser def mp_nofunc(self): return self.getTypedRuleContext(PSParser.Mp_nofuncContext, 0) def getRuleIndex(self): return PSParser.RULE_func_multi_arg_noparens def enterRule(self, listener): if hasattr(listener, "enterFunc_multi_arg_noparens"): listener.enterFunc_multi_arg_noparens(self) def exitRule(self, listener): if hasattr(listener, "exitFunc_multi_arg_noparens"): listener.exitFunc_multi_arg_noparens(self) def func_multi_arg_noparens(self): localctx = PSParser.Func_multi_arg_noparensContext(self, self._ctx, self.state) self.enterRule(localctx, 116, self.RULE_func_multi_arg_noparens) try: self.enterOuterAlt(localctx, 1) self.state = 1014 self.mp_nofunc(0) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SubexprContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.SubexprContext, self).__init__(parent, invokingState) self.parser = parser def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def args(self): return self.getTypedRuleContext(PSParser.ArgsContext, 0) def getRuleIndex(self): return PSParser.RULE_subexpr def enterRule(self, listener): if hasattr(listener, "enterSubexpr"): listener.enterSubexpr(self) def exitRule(self, listener): if hasattr(listener, "exitSubexpr"): listener.exitSubexpr(self) def subexpr(self): localctx = PSParser.SubexprContext(self, self._ctx, self.state) self.enterRule(localctx, 118, self.RULE_subexpr) try: self.enterOuterAlt(localctx, 1) self.state = 1016 self.match(PSParser.UNDERSCORE) self.state = 1025 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT, PSParser.DIFFERENTIAL, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.state = 1017 self.atom() pass elif token in [PSParser.L_BRACE]: self.state = 1018 self.match(PSParser.L_BRACE) self.state = 1021 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input, 89, self._ctx) if la_ == 1: self.state = 1019 self.expr() pass elif la_ == 2: self.state = 1020 self.args() pass self.state = 1023 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SupexprContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.SupexprContext, self).__init__(parent, invokingState) self.parser = parser def CARET(self): return self.getToken(PSParser.CARET, 0) def atom(self): return self.getTypedRuleContext(PSParser.AtomContext, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def expr(self): return self.getTypedRuleContext(PSParser.ExprContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def getRuleIndex(self): return PSParser.RULE_supexpr def enterRule(self, listener): if hasattr(listener, "enterSupexpr"): listener.enterSupexpr(self) def exitRule(self, listener): if hasattr(listener, "exitSupexpr"): listener.exitSupexpr(self) def supexpr(self): localctx = PSParser.SupexprContext(self, self._ctx, self.state) self.enterRule(localctx, 120, self.RULE_supexpr) try: self.enterOuterAlt(localctx, 1) self.state = 1027 self.match(PSParser.CARET) self.state = 1033 self._errHandler.sync(self) token = self._input.LA(1) if token in [PSParser.T__0, PSParser.T__1, PSParser.T__2, PSParser.T__3, PSParser.T__4, PSParser.T__5, PSParser.T__6, PSParser.T__7, PSParser.T__8, PSParser.T__9, PSParser.T__10, PSParser.T__11, PSParser.T__12, PSParser.T__13, PSParser.T__14, PSParser.T__15, PSParser.T__16, PSParser.T__17, PSParser.T__18, PSParser.T__19, PSParser.T__20, PSParser.T__21, PSParser.T__22, PSParser.T__23, PSParser.T__24, PSParser.T__25, PSParser.T__26, PSParser.T__27, PSParser.T__28, PSParser.T__29, PSParser.T__30, PSParser.T__31, PSParser.T__32, PSParser.T__33, PSParser.T__34, PSParser.T__35, PSParser.T__36, PSParser.T__37, PSParser.T__38, PSParser.T__39, PSParser.CMD_MATHIT, PSParser.DIFFERENTIAL, PSParser.LETTER_NO_E, PSParser.NUMBER, PSParser.E_NOTATION, PSParser.PERCENT_NUMBER, PSParser.GREEK_CMD, PSParser.OTHER_SYMBOL_CMD, PSParser.SYMBOL, PSParser.VARIABLE]: self.state = 1028 self.atom() pass elif token in [PSParser.L_BRACE]: self.state = 1029 self.match(PSParser.L_BRACE) self.state = 1030 self.expr() self.state = 1031 self.match(PSParser.R_BRACE) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SubeqContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.SubeqContext, self).__init__(parent, invokingState) self.parser = parser def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def equality(self): return self.getTypedRuleContext(PSParser.EqualityContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def getRuleIndex(self): return PSParser.RULE_subeq def enterRule(self, listener): if hasattr(listener, "enterSubeq"): listener.enterSubeq(self) def exitRule(self, listener): if hasattr(listener, "exitSubeq"): listener.exitSubeq(self) def subeq(self): localctx = PSParser.SubeqContext(self, self._ctx, self.state) self.enterRule(localctx, 122, self.RULE_subeq) try: self.enterOuterAlt(localctx, 1) self.state = 1035 self.match(PSParser.UNDERSCORE) self.state = 1036 self.match(PSParser.L_BRACE) self.state = 1037 self.equality() self.state = 1038 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class SupeqContext(ParserRuleContext): def __init__(self, parser, parent=None, invokingState=-1): super(PSParser.SupeqContext, self).__init__(parent, invokingState) self.parser = parser def UNDERSCORE(self): return self.getToken(PSParser.UNDERSCORE, 0) def L_BRACE(self): return self.getToken(PSParser.L_BRACE, 0) def equality(self): return self.getTypedRuleContext(PSParser.EqualityContext, 0) def R_BRACE(self): return self.getToken(PSParser.R_BRACE, 0) def getRuleIndex(self): return PSParser.RULE_supeq def enterRule(self, listener): if hasattr(listener, "enterSupeq"): listener.enterSupeq(self) def exitRule(self, listener): if hasattr(listener, "exitSupeq"): listener.exitSupeq(self) def supeq(self): localctx = PSParser.SupeqContext(self, self._ctx, self.state) self.enterRule(localctx, 124, self.RULE_supeq) try: self.enterOuterAlt(localctx, 1) self.state = 1040 self.match(PSParser.UNDERSCORE) self.state = 1041 self.match(PSParser.L_BRACE) self.state = 1042 self.equality() self.state = 1043 self.match(PSParser.R_BRACE) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx def sempred(self, localctx, ruleIndex, predIndex): if self._predicates == None: self._predicates = dict() self._predicates[12] = self.relation_sempred self._predicates[17] = self.additive_sempred self._predicates[18] = self.mp_sempred self._predicates[19] = self.mp_nofunc_sempred self._predicates[28] = self.exp_sempred self._predicates[29] = self.exp_nofunc_sempred pred = self._predicates.get(ruleIndex, None) if pred is None: raise Exception("No predicate with index:" + str(ruleIndex)) else: return pred(localctx, predIndex) def relation_sempred(self, localctx, predIndex): if predIndex == 0: return self.precpred(self._ctx, 2) def additive_sempred(self, localctx, predIndex): if predIndex == 1: return self.precpred(self._ctx, 2) def mp_sempred(self, localctx, predIndex): if predIndex == 2: return self.precpred(self._ctx, 2) def mp_nofunc_sempred(self, localctx, predIndex): if predIndex == 3: return self.precpred(self._ctx, 2) def exp_sempred(self, localctx, predIndex): if predIndex == 4: return self.precpred(self._ctx, 2) def exp_nofunc_sempred(self, localctx, predIndex): if predIndex == 5: return self.precpred(self._ctx, 2)