# Generated from SMTLIBv2.g4 by ANTLR 4.9.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys

if sys.version_info[1] > 5:
    from typing import TextIO
else:
    from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u008d")
        buf.write("\u05a6\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write('\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%\4&\t')
        buf.write("&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
        buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
        buf.write("z\tz\3\2\3\2\3\2\3\3\3\3\3\3\3\4\3\4\3\5\3\5\5\5\u00ff")
        buf.write("\n\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\5\t\u0109\n\t\3\n")
        buf.write("\3\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20")
        buf.write("\3\20\3\20\5\20\u011a\n\20\3\21\3\21\3\21\3\21\3\21\3")
        buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u012a")
        buf.write("\n\21\3\22\3\22\3\22\3\22\3\22\7\22\u0131\n\22\f\22\16")
        buf.write("\22\u0134\13\22\3\22\5\22\u0137\n\22\3\23\3\23\5\23\u013b")
        buf.write("\n\23\3\24\3\24\3\24\3\24\3\24\6\24\u0142\n\24\r\24\16")
        buf.write("\24\u0143\3\24\3\24\5\24\u0148\n\24\3\25\3\25\3\25\3\25")
        buf.write("\7\25\u014e\n\25\f\25\16\25\u0151\13\25\3\25\5\25\u0154")
        buf.write("\n\25\3\26\3\26\3\26\3\26\5\26\u015a\n\26\3\27\3\27\3")
        buf.write("\27\3\27\6\27\u0160\n\27\r\27\16\27\u0161\3\27\3\27\5")
        buf.write("\27\u0166\n\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30")
        buf.write("\u016f\n\30\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3")
        buf.write("\32\3\32\3\33\3\33\3\33\3\33\6\33\u017f\n\33\r\33\16\33")
        buf.write("\u0180\3\33\3\33\5\33\u0185\n\33\3\34\3\34\3\34\3\34\3")
        buf.write("\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\3\35\6\35\u0197\n\35\r\35\16\35\u0198\3\35\3\35\3\35")
        buf.write("\3\35\3\35\3\35\3\35\6\35\u01a2\n\35\r\35\16\35\u01a3")
        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35\u01ad\n\35\r")
        buf.write("\35\16\35\u01ae\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\6\35\u01b9\n\35\r\35\16\35\u01ba\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\35\3\35\3\35\6\35\u01c5\n\35\r\35\16\35\u01c6")
        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35\u01d2")
        buf.write("\n\35\r\35\16\35\u01d3\3\35\3\35\3\35\3\35\3\35\3\35\3")
        buf.write("\35\6\35\u01dd\n\35\r\35\16\35\u01de\3\35\3\35\5\35\u01e3")
        buf.write("\n\35\3\36\3\36\3\36\3\36\7\36\u01e9\n\36\f\36\16\36\u01ec")
        buf.write("\13\36\3\36\3\36\3\37\3\37\3 \3 \3 \3 \7 \u01f6\n \f ")
        buf.write("\16 \u01f9\13 \3 \3 \3 \3 \3 \3 \7 \u0201\n \f \16 \u0204")
        buf.write("\13 \3 \3 \3 \3 \3 \6 \u020b\n \r \16 \u020c\3 \7 \u0210")
        buf.write("\n \f \16 \u0213\13 \3 \3 \5 \u0217\n \3!\3!\3!\3!\3!")
        buf.write("\6!\u021e\n!\r!\16!\u021f\3!\3!\3!\3!\6!\u0226\n!\r!\16")
        buf.write("!\u0227\3!\7!\u022b\n!\f!\16!\u022e\13!\3!\3!\3!\5!\u0233")
        buf.write('\n!\3"\3"\3"\6"\u0238\n"\r"\16"\u0239\3"\3"\3')
        buf.write('"\3"\3"\6"\u0241\n"\r"\16"\u0242\3"\3"\3"\3')
        buf.write('"\3"\3"\3"\3"\3"\3"\3"\3"\3"\5"\u0252\n"\3')
        buf.write("#\3#\3#\3#\6#\u0258\n#\r#\16#\u0259\3#\3#\3$\3$\3$\6$")
        buf.write("\u0261\n$\r$\16$\u0262\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3")
        buf.write("$\5$\u0270\n$\3%\3%\3%\3%\6%\u0276\n%\r%\16%\u0277\3%")
        buf.write("\3%\3&\3&\3&\3&\3&\3'\3'\3'\3'\3'\3(\3(\3(\7(\u0289")
        buf.write("\n(\f(\16(\u028c\13(\3(\3(\3)\3)\6)\u0292\n)\r)\16)\u0293")
        buf.write("\3)\3)\3)\3)\3)\3)\6)\u029c\n)\r)\16)\u029d\3)\3)\3)\6")
        buf.write(")\u02a3\n)\r)\16)\u02a4\3)\3)\3)\5)\u02aa\n)\3*\3*\3*")
        buf.write("\3*\7*\u02b0\n*\f*\16*\u02b3\13*\3*\3*\3*\3*\3+\3+\3+")
        buf.write("\7+\u02bc\n+\f+\16+\u02bf\13+\3+\3+\3+\3+\3,\3,\3,\3,")
        buf.write("\3,\3,\5,\u02cb\n,\3-\7-\u02ce\n-\f-\16-\u02d1\13-\3.")
        buf.write("\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\63\3\63\3\64")
        buf.write("\3\64\3\65\3\65\3\66\3\66\3\67\3\67\38\38\39\39\3:\3:")
        buf.write("\3;\3;\3<\3<\3=\3=\3>\3>\3?\3?\3@\3@\3A\3A\3B\3B\3C\3")
        buf.write("C\3D\3D\3E\3E\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3L\3")
        buf.write("L\3M\3M\3N\3N\3O\3O\3P\3P\3Q\3Q\3R\3R\3S\3S\3T\3T\3U\3")
        buf.write("U\3V\3V\3W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3\\\3\\\3]\3]\3")
        buf.write("^\3^\3_\3_\3`\3`\3a\3a\3b\3b\3c\3c\3c\3c\3c\3c\5c\u0343")
        buf.write("\nc\3c\3c\3c\3c\3c\6c\u034a\nc\rc\16c\u034b\3c\3c\3c\3")
        buf.write("c\3c\6c\u0353\nc\rc\16c\u0354\3c\3c\3c\3c\3c\6c\u035c")
        buf.write("\nc\rc\16c\u035d\3c\3c\3c\3c\3c\3c\6c\u0366\nc\rc\16c")
        buf.write("\u0367\3c\3c\3c\3c\3c\3c\6c\u0370\nc\rc\16c\u0371\3c\3")
        buf.write("c\3c\3c\3c\6c\u0379\nc\rc\16c\u037a\3c\3c\3c\3c\3c\6c")
        buf.write("\u0382\nc\rc\16c\u0383\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3")
        buf.write("c\3c\3c\6c\u0393\nc\rc\16c\u0394\3c\3c\5c\u0399\nc\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\7d\u03a4\nd\fd\16d\u03a7\13d")
        buf.write("\3d\3d\3d\3d\3d\7d\u03ae\nd\fd\16d\u03b1\13d\3d\3d\3d")
        buf.write("\3d\3d\3d\7d\u03b9\nd\fd\16d\u03bc\13d\3d\3d\3d\3d\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\7d\u03cf\nd\fd\16")
        buf.write("d\u03d2\13d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\6d\u03ec\nd\rd\16d\u03ed")
        buf.write("\3d\3d\3d\6d\u03f3\nd\rd\16d\u03f4\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\6d\u03fe\nd\rd\16d\u03ff\3d\3d\3d\3d\3d\6d\u0407\nd")
        buf.write("\rd\16d\u0408\3d\3d\3d\3d\3d\3d\3d\3d\7d\u0413\nd\fd\16")
        buf.write("d\u0416\13d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u0420\nd\3d\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\6d\u043f\nd\rd\16d\u0440")
        buf.write("\3d\3d\3d\6d\u0446\nd\rd\16d\u0447\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\7d\u0457\nd\fd\16d\u045a\13d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\6d\u0464\nd\rd\16d\u0465\3d\3d\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\6d\u04a1\nd\rd\16d\u04a2\3d\3d\3d\3d\3d\3d\3d\3d\3d")
        buf.write("\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3")
        buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u04df\nd\3")
        buf.write("e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3")
        buf.write("f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\5f\u0500\nf\3g\3")
        buf.write("g\3g\3g\3g\3g\3g\3g\5g\u050a\ng\3h\3h\3i\3i\3i\5i\u0511")
        buf.write("\ni\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\6j\u0521")
        buf.write("\nj\rj\16j\u0522\3j\3j\3j\6j\u0528\nj\rj\16j\u0529\3j")
        buf.write("\3j\3j\5j\u052f\nj\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3")
        buf.write("k\3k\5k\u053e\nk\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3n\3n\3")
        buf.write("o\3o\3p\3p\7p\u0550\np\fp\16p\u0553\13p\3p\3p\3q\3q\7")
        buf.write("q\u0559\nq\fq\16q\u055c\13q\3q\3q\3r\3r\6r\u0562\nr\r")
        buf.write("r\16r\u0563\3r\3r\3s\3s\7s\u056a\ns\fs\16s\u056d\13s\3")
        buf.write("s\3s\3t\3t\3u\3u\3v\3v\7v\u0577\nv\fv\16v\u057a\13v\3")
        buf.write("v\3v\3w\3w\7w\u0580\nw\fw\16w\u0583\13w\3w\3w\3x\3x\6")
        buf.write("x\u0589\nx\rx\16x\u058a\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y")
        buf.write("\3y\3y\3y\5y\u059a\ny\3z\3z\3z\3z\3z\3z\3z\3z\5z\u05a4")
        buf.write('\nz\3z\2\2{\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 "')
        buf.write("$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz")
        buf.write("|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090")
        buf.write("\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2")
        buf.write("\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4")
        buf.write("\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6")
        buf.write("\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8")
        buf.write("\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea")
        buf.write("\u00ec\u00ee\u00f0\u00f2\2\t\3\2R]\3\2\13\34\3\2c\u008b")
        buf.write("\4\2VV\\\\\4\2\21\21\31\31\4\2\17\17\22\22\5\2\26\26\32")
        buf.write("\32\34\34\2\u0603\2\u00f4\3\2\2\2\4\u00f7\3\2\2\2\6\u00fa")
        buf.write("\3\2\2\2\b\u00fe\3\2\2\2\n\u0100\3\2\2\2\f\u0102\3\2\2")
        buf.write("\2\16\u0104\3\2\2\2\20\u0108\3\2\2\2\22\u010a\3\2\2\2")
        buf.write("\24\u010c\3\2\2\2\26\u010e\3\2\2\2\30\u0110\3\2\2\2\32")
        buf.write("\u0112\3\2\2\2\34\u0114\3\2\2\2\36\u0119\3\2\2\2 \u0129")
        buf.write('\3\2\2\2"\u0136\3\2\2\2$\u013a\3\2\2\2&\u0147\3\2\2\2')
        buf.write("(\u0153\3\2\2\2*\u0159\3\2\2\2,\u0165\3\2\2\2.\u016e\3")
        buf.write("\2\2\2\60\u0170\3\2\2\2\62\u0175\3\2\2\2\64\u0184\3\2")
        buf.write("\2\2\66\u0186\3\2\2\28\u01e2\3\2\2\2:\u01e4\3\2\2\2<\u01ef")
        buf.write("\3\2\2\2>\u0216\3\2\2\2@\u0232\3\2\2\2B\u0251\3\2\2\2")
        buf.write("D\u0253\3\2\2\2F\u026f\3\2\2\2H\u0271\3\2\2\2J\u027b\3")
        buf.write("\2\2\2L\u0280\3\2\2\2N\u0285\3\2\2\2P\u02a9\3\2\2\2R\u02ab")
        buf.write("\3\2\2\2T\u02b8\3\2\2\2V\u02ca\3\2\2\2X\u02cf\3\2\2\2")
        buf.write("Z\u02d2\3\2\2\2\\\u02d4\3\2\2\2^\u02d6\3\2\2\2`\u02d8")
        buf.write("\3\2\2\2b\u02da\3\2\2\2d\u02dc\3\2\2\2f\u02de\3\2\2\2")
        buf.write("h\u02e0\3\2\2\2j\u02e2\3\2\2\2l\u02e4\3\2\2\2n\u02e6\3")
        buf.write("\2\2\2p\u02e8\3\2\2\2r\u02ea\3\2\2\2t\u02ec\3\2\2\2v\u02ee")
        buf.write("\3\2\2\2x\u02f0\3\2\2\2z\u02f2\3\2\2\2|\u02f4\3\2\2\2")
        buf.write("~\u02f6\3\2\2\2\u0080\u02f8\3\2\2\2\u0082\u02fa\3\2\2")
        buf.write("\2\u0084\u02fc\3\2\2\2\u0086\u02fe\3\2\2\2\u0088\u0300")
        buf.write("\3\2\2\2\u008a\u0302\3\2\2\2\u008c\u0304\3\2\2\2\u008e")
        buf.write("\u0306\3\2\2\2\u0090\u0308\3\2\2\2\u0092\u030a\3\2\2\2")
        buf.write("\u0094\u030c\3\2\2\2\u0096\u030e\3\2\2\2\u0098\u0310\3")
        buf.write("\2\2\2\u009a\u0312\3\2\2\2\u009c\u0314\3\2\2\2\u009e\u0316")
        buf.write("\3\2\2\2\u00a0\u0318\3\2\2\2\u00a2\u031a\3\2\2\2\u00a4")
        buf.write("\u031c\3\2\2\2\u00a6\u031e\3\2\2\2\u00a8\u0320\3\2\2\2")
        buf.write("\u00aa\u0322\3\2\2\2\u00ac\u0324\3\2\2\2\u00ae\u0326\3")
        buf.write("\2\2\2\u00b0\u0328\3\2\2\2\u00b2\u032a\3\2\2\2\u00b4\u032c")
        buf.write("\3\2\2\2\u00b6\u032e\3\2\2\2\u00b8\u0330\3\2\2\2\u00ba")
        buf.write("\u0332\3\2\2\2\u00bc\u0334\3\2\2\2\u00be\u0336\3\2\2\2")
        buf.write("\u00c0\u0338\3\2\2\2\u00c2\u033a\3\2\2\2\u00c4\u0398\3")
        buf.write("\2\2\2\u00c6\u04de\3\2\2\2\u00c8\u04e0\3\2\2\2\u00ca\u04ff")
        buf.write("\3\2\2\2\u00cc\u0509\3\2\2\2\u00ce\u050b\3\2\2\2\u00d0")
        buf.write("\u0510\3\2\2\2\u00d2\u052e\3\2\2\2\u00d4\u053d\3\2\2\2")
        buf.write("\u00d6\u053f\3\2\2\2\u00d8\u0544\3\2\2\2\u00da\u0549\3")
        buf.write("\2\2\2\u00dc\u054b\3\2\2\2\u00de\u054d\3\2\2\2\u00e0\u0556")
        buf.write("\3\2\2\2\u00e2\u055f\3\2\2\2\u00e4\u0567\3\2\2\2\u00e6")
        buf.write("\u0570\3\2\2\2\u00e8\u0572\3\2\2\2\u00ea\u0574\3\2\2\2")
        buf.write("\u00ec\u057d\3\2\2\2\u00ee\u0586\3\2\2\2\u00f0\u0599\3")
        buf.write("\2\2\2\u00f2\u05a3\3\2\2\2\u00f4\u00f5\5X-\2\u00f5\u00f6")
        buf.write("\7\2\2\3\u00f6\3\3\2\2\2\u00f7\u00f8\5\u00f2z\2\u00f8")
        buf.write("\u00f9\7\2\2\3\u00f9\5\3\2\2\2\u00fa\u00fb\t\2\2\2\u00fb")
        buf.write("\7\3\2\2\2\u00fc\u00ff\5\f\7\2\u00fd\u00ff\7\u008c\2\2")
        buf.write("\u00fe\u00fc\3\2\2\2\u00fe\u00fd\3\2\2\2\u00ff\t\3\2\2")
        buf.write("\2\u0100\u0101\7\t\2\2\u0101\13\3\2\2\2\u0102\u0103\t")
        buf.write("\3\2\2\u0103\r\3\2\2\2\u0104\u0105\t\4\2\2\u0105\17\3")
        buf.write("\2\2\2\u0106\u0109\5\b\5\2\u0107\u0109\5\n\6\2\u0108\u0106")
        buf.write("\3\2\2\2\u0108\u0107\3\2\2\2\u0109\21\3\2\2\2\u010a\u010b")
        buf.write("\7^\2\2\u010b\23\3\2\2\2\u010c\u010d\7a\2\2\u010d\25\3")
        buf.write("\2\2\2\u010e\u010f\7`\2\2\u010f\27\3\2\2\2\u0110\u0111")
        buf.write("\7_\2\2\u0111\31\3\2\2\2\u0112\u0113\7\b\2\2\u0113\33")
        buf.write("\3\2\2\2\u0114\u0115\7\n\2\2\u0115\35\3\2\2\2\u0116\u011a")
        buf.write("\5\16\b\2\u0117\u0118\7b\2\2\u0118\u011a\5\b\5\2\u0119")
        buf.write("\u0116\3\2\2\2\u0119\u0117\3\2\2\2\u011a\37\3\2\2\2\u011b")
        buf.write("\u012a\5\22\n\2\u011c\u012a\5\24\13\2\u011d\u012a\5\26")
        buf.write("\f\2\u011e\u012a\5\30\r\2\u011f\u012a\5\32\16\2\u0120")
        buf.write("\u012a\5\u00c8e\2\u0121\u012a\5\34\17\2\u0122\u0123\7")
        buf.write("\5\2\2\u0123\u0124\7S\2\2\u0124\u0125\7\3\2\2\u0125\u0126")
        buf.write("\5\22\n\2\u0126\u0127\5\22\n\2\u0127\u0128\7\6\2\2\u0128")
        buf.write("\u012a\3\2\2\2\u0129\u011b\3\2\2\2\u0129\u011c\3\2\2\2")
        buf.write("\u0129\u011d\3\2\2\2\u0129\u011e\3\2\2\2\u0129\u011f\3")
        buf.write("\2\2\2\u0129\u0120\3\2\2\2\u0129\u0121\3\2\2\2\u0129\u0122")
        buf.write("\3\2\2\2\u012a!\3\2\2\2\u012b\u0137\5 \21\2\u012c\u0137")
        buf.write("\5\20\t\2\u012d\u0137\5\36\20\2\u012e\u0132\7\5\2\2\u012f")
        buf.write('\u0131\5"\22\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2')
        buf.write("\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0135")
        buf.write("\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u0137\7\6\2\2\u0136")
        buf.write("\u012b\3\2\2\2\u0136\u012c\3\2\2\2\u0136\u012d\3\2\2\2")
        buf.write("\u0136\u012e\3\2\2\2\u0137#\3\2\2\2\u0138\u013b\5\22\n")
        buf.write("\2\u0139\u013b\5\20\t\2\u013a\u0138\3\2\2\2\u013a\u0139")
        buf.write("\3\2\2\2\u013b%\3\2\2\2\u013c\u0148\5\20\t\2\u013d\u013e")
        buf.write("\7\5\2\2\u013e\u013f\7S\2\2\u013f\u0141\5\20\t\2\u0140")
        buf.write("\u0142\5$\23\2\u0141\u0140\3\2\2\2\u0142\u0143\3\2\2\2")
        buf.write("\u0143\u0141\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0145\3")
        buf.write("\2\2\2\u0145\u0146\7\6\2\2\u0146\u0148\3\2\2\2\u0147\u013c")
        buf.write("\3\2\2\2\u0147\u013d\3\2\2\2\u0148'\3\2\2\2\u0149\u0154")
        buf.write("\5 \21\2\u014a\u0154\5\20\t\2\u014b\u014f\7\5\2\2\u014c")
        buf.write('\u014e\5"\22\2\u014d\u014c\3\2\2\2\u014e\u0151\3\2\2')
        buf.write("\2\u014f\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152")
        buf.write("\3\2\2\2\u0151\u014f\3\2\2\2\u0152\u0154\7\6\2\2\u0153")
        buf.write("\u0149\3\2\2\2\u0153\u014a\3\2\2\2\u0153\u014b\3\2\2\2")
        buf.write("\u0154)\3\2\2\2\u0155\u015a\5\36\20\2\u0156\u0157\5\36")
        buf.write("\20\2\u0157\u0158\5(\25\2\u0158\u015a\3\2\2\2\u0159\u0155")
        buf.write("\3\2\2\2\u0159\u0156\3\2\2\2\u015a+\3\2\2\2\u015b\u0166")
        buf.write("\5&\24\2\u015c\u015d\7\5\2\2\u015d\u015f\5&\24\2\u015e")
        buf.write("\u0160\5,\27\2\u015f\u015e\3\2\2\2\u0160\u0161\3\2\2\2")
        buf.write("\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163\3")
        buf.write("\2\2\2\u0163\u0164\7\6\2\2\u0164\u0166\3\2\2\2\u0165\u015b")
        buf.write("\3\2\2\2\u0165\u015c\3\2\2\2\u0166-\3\2\2\2\u0167\u016f")
        buf.write("\5&\24\2\u0168\u0169\7\5\2\2\u0169\u016a\7T\2\2\u016a")
        buf.write("\u016b\5&\24\2\u016b\u016c\5,\27\2\u016c\u016d\7\6\2\2")
        buf.write("\u016d\u016f\3\2\2\2\u016e\u0167\3\2\2\2\u016e\u0168\3")
        buf.write("\2\2\2\u016f/\3\2\2\2\u0170\u0171\7\5\2\2\u0171\u0172")
        buf.write("\5\20\t\2\u0172\u0173\58\35\2\u0173\u0174\7\6\2\2\u0174")
        buf.write("\61\3\2\2\2\u0175\u0176\7\5\2\2\u0176\u0177\5\20\t\2\u0177")
        buf.write("\u0178\5,\27\2\u0178\u0179\7\6\2\2\u0179\63\3\2\2\2\u017a")
        buf.write("\u0185\5\20\t\2\u017b\u017c\7\5\2\2\u017c\u017e\5\20\t")
        buf.write("\2\u017d\u017f\5\20\t\2\u017e\u017d\3\2\2\2\u017f\u0180")
        buf.write("\3\2\2\2\u0180\u017e\3\2\2\2\u0180\u0181\3\2\2\2\u0181")
        buf.write("\u0182\3\2\2\2\u0182\u0183\7\6\2\2\u0183\u0185\3\2\2\2")
        buf.write("\u0184\u017a\3\2\2\2\u0184\u017b\3\2\2\2\u0185\65\3\2")
        buf.write("\2\2\u0186\u0187\7\5\2\2\u0187\u0188\5\64\33\2\u0188\u0189")
        buf.write("\58\35\2\u0189\u018a\7\6\2\2\u018a\67\3\2\2\2\u018b\u01e3")
        buf.write("\5 \21\2\u018c\u018d\7\5\2\2\u018d\u018e\7S\2\2\u018e")
        buf.write("\u018f\5\20\t\2\u018f\u0190\5\22\n\2\u0190\u0191\7\6\2")
        buf.write("\2\u0191\u01e3\3\2\2\2\u0192\u01e3\5.\30\2\u0193\u0194")
        buf.write("\7\5\2\2\u0194\u0196\5.\30\2\u0195\u0197\58\35\2\u0196")
        buf.write("\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u0196\3\2\2\2")
        buf.write("\u0198\u0199\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019b\7")
        buf.write("\6\2\2\u019b\u01e3\3\2\2\2\u019c\u019d\7\5\2\2\u019d\u019e")
        buf.write("\7\5\2\2\u019e\u019f\7S\2\2\u019f\u01a1\5.\30\2\u01a0")
        buf.write("\u01a2\58\35\2\u01a1\u01a0\3\2\2\2\u01a2\u01a3\3\2\2\2")
        buf.write("\u01a3\u01a1\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a5\3")
        buf.write("\2\2\2\u01a5\u01a6\7\6\2\2\u01a6\u01a7\7\6\2\2\u01a7\u01e3")
        buf.write("\3\2\2\2\u01a8\u01a9\7\5\2\2\u01a9\u01aa\7Z\2\2\u01aa")
        buf.write("\u01ac\7\5\2\2\u01ab\u01ad\5\60\31\2\u01ac\u01ab\3\2\2")
        buf.write("\2\u01ad\u01ae\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01af")
        buf.write("\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\7\6\2\2\u01b1")
        buf.write("\u01b2\58\35\2\u01b2\u01b3\7\6\2\2\u01b3\u01e3\3\2\2\2")
        buf.write("\u01b4\u01b5\7\5\2\2\u01b5\u01b6\7Y\2\2\u01b6\u01b8\7")
        buf.write("\5\2\2\u01b7\u01b9\5\62\32\2\u01b8\u01b7\3\2\2\2\u01b9")
        buf.write("\u01ba\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2")
        buf.write("\u01bb\u01bc\3\2\2\2\u01bc\u01bd\7\6\2\2\u01bd\u01be\5")
        buf.write("8\35\2\u01be\u01bf\7\6\2\2\u01bf\u01e3\3\2\2\2\u01c0\u01c1")
        buf.write("\7\5\2\2\u01c1\u01c2\7W\2\2\u01c2\u01c4\7\5\2\2\u01c3")
        buf.write("\u01c5\5\62\32\2\u01c4\u01c3\3\2\2\2\u01c5\u01c6\3\2\2")
        buf.write("\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8")
        buf.write("\3\2\2\2\u01c8\u01c9\7\6\2\2\u01c9\u01ca\58\35\2\u01ca")
        buf.write("\u01cb\7\6\2\2\u01cb\u01e3\3\2\2\2\u01cc\u01cd\7\5\2\2")
        buf.write("\u01cd\u01ce\7[\2\2\u01ce\u01cf\58\35\2\u01cf\u01d1\7")
        buf.write("\5\2\2\u01d0\u01d2\5\66\34\2\u01d1\u01d0\3\2\2\2\u01d2")
        buf.write("\u01d3\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2")
        buf.write("\u01d4\u01d5\3\2\2\2\u01d5\u01d6\7\6\2\2\u01d6\u01d7\7")
        buf.write("\6\2\2\u01d7\u01e3\3\2\2\2\u01d8\u01d9\7\5\2\2\u01d9\u01da")
        buf.write("\7R\2\2\u01da\u01dc\58\35\2\u01db\u01dd\5*\26\2\u01dc")
        buf.write("\u01db\3\2\2\2\u01dd\u01de\3\2\2\2\u01de\u01dc\3\2\2\2")
        buf.write("\u01de\u01df\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e1\7")
        buf.write("\6\2\2\u01e1\u01e3\3\2\2\2\u01e2\u018b\3\2\2\2\u01e2\u018c")
        buf.write("\3\2\2\2\u01e2\u0192\3\2\2\2\u01e2\u0193\3\2\2\2\u01e2")
        buf.write("\u019c\3\2\2\2\u01e2\u01a8\3\2\2\2\u01e2\u01b4\3\2\2\2")
        buf.write("\u01e2\u01c0\3\2\2\2\u01e2\u01cc\3\2\2\2\u01e2\u01d8\3")
        buf.write("\2\2\2\u01e39\3\2\2\2\u01e4\u01e5\7\5\2\2\u01e5\u01e6")
        buf.write("\5&\24\2\u01e6\u01ea\5\22\n\2\u01e7\u01e9\5*\26\2\u01e8")
        buf.write("\u01e7\3\2\2\2\u01e9\u01ec\3\2\2\2\u01ea\u01e8\3\2\2\2")
        buf.write("\u01ea\u01eb\3\2\2\2\u01eb\u01ed\3\2\2\2\u01ec\u01ea\3")
        buf.write("\2\2\2\u01ed\u01ee\7\6\2\2\u01ee;\3\2\2\2\u01ef\u01f0")
        buf.write("\t\5\2\2\u01f0=\3\2\2\2\u01f1\u01f2\7\5\2\2\u01f2\u01f3")
        buf.write("\5 \21\2\u01f3\u01f7\5,\27\2\u01f4\u01f6\5*\26\2\u01f5")
        buf.write("\u01f4\3\2\2\2\u01f6\u01f9\3\2\2\2\u01f7\u01f5\3\2\2\2")
        buf.write("\u01f7\u01f8\3\2\2\2\u01f8\u01fa\3\2\2\2\u01f9\u01f7\3")
        buf.write("\2\2\2\u01fa\u01fb\7\6\2\2\u01fb\u0217\3\2\2\2\u01fc\u01fd")
        buf.write("\7\5\2\2\u01fd\u01fe\5<\37\2\u01fe\u0202\5,\27\2\u01ff")
        buf.write("\u0201\5*\26\2\u0200\u01ff\3\2\2\2\u0201\u0204\3\2\2\2")
        buf.write("\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0205\3")
        buf.write("\2\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7\6\2\2\u0206\u0217")
        buf.write("\3\2\2\2\u0207\u0208\7\5\2\2\u0208\u020a\5&\24\2\u0209")
        buf.write("\u020b\5,\27\2\u020a\u0209\3\2\2\2\u020b\u020c\3\2\2\2")
        buf.write("\u020c\u020a\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u0211\3")
        buf.write("\2\2\2\u020e\u0210\5*\26\2\u020f\u020e\3\2\2\2\u0210\u0213")
        buf.write("\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0212\3\2\2\2\u0212")
        buf.write("\u0214\3\2\2\2\u0213\u0211\3\2\2\2\u0214\u0215\7\6\2\2")
        buf.write("\u0215\u0217\3\2\2\2\u0216\u01f1\3\2\2\2\u0216\u01fc\3")
        buf.write("\2\2\2\u0216\u0207\3\2\2\2\u0217?\3\2\2\2\u0218\u0233")
        buf.write("\5> \2\u0219\u021a\7\5\2\2\u021a\u021b\7]\2\2\u021b\u021d")
        buf.write("\7\5\2\2\u021c\u021e\5\20\t\2\u021d\u021c\3\2\2\2\u021e")
        buf.write("\u021f\3\2\2\2\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2")
        buf.write("\u0220\u0221\3\2\2\2\u0221\u0222\7\6\2\2\u0222\u0223\7")
        buf.write("\5\2\2\u0223\u0225\5&\24\2\u0224\u0226\5,\27\2\u0225\u0224")
        buf.write("\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0225\3\2\2\2\u0227")
        buf.write("\u0228\3\2\2\2\u0228\u022c\3\2\2\2\u0229\u022b\5*\26\2")
        buf.write("\u022a\u0229\3\2\2\2\u022b\u022e\3\2\2\2\u022c\u022a\3")
        buf.write("\2\2\2\u022c\u022d\3\2\2\2\u022d\u022f\3\2\2\2\u022e\u022c")
        buf.write("\3\2\2\2\u022f\u0230\7\6\2\2\u0230\u0231\7\6\2\2\u0231")
        buf.write("\u0233\3\2\2\2\u0232\u0218\3\2\2\2\u0232\u0219\3\2\2\2")
        buf.write("\u0233A\3\2\2\2\u0234\u0235\7\u0084\2\2\u0235\u0237\7")
        buf.write("\5\2\2\u0236\u0238\5:\36\2\u0237\u0236\3\2\2\2\u0238\u0239")
        buf.write("\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u023a\3\2\2\2\u023a")
        buf.write("\u023b\3\2\2\2\u023b\u023c\7\6\2\2\u023c\u0252\3\2\2\2")
        buf.write("\u023d\u023e\7l\2\2\u023e\u0240\7\5\2\2\u023f\u0241\5")
        buf.write("@!\2\u0240\u023f\3\2\2\2\u0241\u0242\3\2\2\2\u0242\u0240")
        buf.write("\3\2\2\2\u0242\u0243\3\2\2\2\u0243\u0244\3\2\2\2\u0244")
        buf.write("\u0245\7\6\2\2\u0245\u0252\3\2\2\2\u0246\u0247\7\u0085")
        buf.write("\2\2\u0247\u0252\5\32\16\2\u0248\u0249\7m\2\2\u0249\u0252")
        buf.write("\5\32\16\2\u024a\u024b\7h\2\2\u024b\u0252\5\32\16\2\u024c")
        buf.write("\u024d\7\u0089\2\2\u024d\u0252\5\32\16\2\u024e\u024f\7")
        buf.write("u\2\2\u024f\u0252\5\32\16\2\u0250\u0252\5*\26\2\u0251")
        buf.write("\u0234\3\2\2\2\u0251\u023d\3\2\2\2\u0251\u0246\3\2\2\2")
        buf.write("\u0251\u0248\3\2\2\2\u0251\u024a\3\2\2\2\u0251\u024c\3")
        buf.write("\2\2\2\u0251\u024e\3\2\2\2\u0251\u0250\3\2\2\2\u0252C")
        buf.write("\3\2\2\2\u0253\u0254\7\5\2\2\u0254\u0255\7\30\2\2\u0255")
        buf.write('\u0257\5\20\t\2\u0256\u0258\5B"\2\u0257\u0256\3\2\2\2')
        buf.write("\u0258\u0259\3\2\2\2\u0259\u0257\3\2\2\2\u0259\u025a\3")
        buf.write("\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\7\6\2\2\u025cE")
        buf.write("\3\2\2\2\u025d\u025e\7\u0088\2\2\u025e\u0260\7\5\2\2\u025f")
        buf.write("\u0261\5\20\t\2\u0260\u025f\3\2\2\2\u0261\u0262\3\2\2")
        buf.write("\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0264")
        buf.write("\3\2\2\2\u0264\u0265\7\6\2\2\u0265\u0270\3\2\2\2\u0266")
        buf.write("\u0267\7p\2\2\u0267\u0270\5\32\16\2\u0268\u0269\7k\2\2")
        buf.write("\u0269\u0270\5\32\16\2\u026a\u026b\7\u0089\2\2\u026b\u0270")
        buf.write("\5\32\16\2\u026c\u026d\7u\2\2\u026d\u0270\5\32\16\2\u026e")
        buf.write("\u0270\5*\26\2\u026f\u025d\3\2\2\2\u026f\u0266\3\2\2\2")
        buf.write("\u026f\u0268\3\2\2\2\u026f\u026a\3\2\2\2\u026f\u026c\3")
        buf.write("\2\2\2\u026f\u026e\3\2\2\2\u0270G\3\2\2\2\u0271\u0272")
        buf.write("\7\5\2\2\u0272\u0273\7\24\2\2\u0273\u0275\5\20\t\2\u0274")
        buf.write("\u0276\5F$\2\u0275\u0274\3\2\2\2\u0276\u0277\3\2\2\2\u0277")
        buf.write("\u0275\3\2\2\2\u0277\u0278\3\2\2\2\u0278\u0279\3\2\2\2")
        buf.write("\u0279\u027a\7\6\2\2\u027aI\3\2\2\2\u027b\u027c\7\5\2")
        buf.write("\2\u027c\u027d\5\20\t\2\u027d\u027e\5\22\n\2\u027e\u027f")
        buf.write("\7\6\2\2\u027fK\3\2\2\2\u0280\u0281\7\5\2\2\u0281\u0282")
        buf.write("\5\20\t\2\u0282\u0283\5,\27\2\u0283\u0284\7\6\2\2\u0284")
        buf.write("M\3\2\2\2\u0285\u0286\7\5\2\2\u0286\u028a\5\20\t\2\u0287")
        buf.write("\u0289\5L'\2\u0288\u0287\3\2\2\2\u0289\u028c\3\2\2\2")
        buf.write("\u028a\u0288\3\2\2\2\u028a\u028b\3\2\2\2\u028b\u028d\3")
        buf.write("\2\2\2\u028c\u028a\3\2\2\2\u028d\u028e\7\6\2\2\u028eO")
        buf.write("\3\2\2\2\u028f\u0291\7\5\2\2\u0290\u0292\5N(\2\u0291\u0290")
        buf.write("\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0291\3\2\2\2\u0293")
        buf.write("\u0294\3\2\2\2\u0294\u0295\3\2\2\2\u0295\u0296\7\6\2\2")
        buf.write("\u0296\u02aa\3\2\2\2\u0297\u0298\7\5\2\2\u0298\u0299\7")
        buf.write("]\2\2\u0299\u029b\7\5\2\2\u029a\u029c\5\20\t\2\u029b\u029a")
        buf.write("\3\2\2\2\u029c\u029d\3\2\2\2\u029d\u029b\3\2\2\2\u029d")
        buf.write("\u029e\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u02a0\7\6\2\2")
        buf.write("\u02a0\u02a2\7\5\2\2\u02a1\u02a3\5N(\2\u02a2\u02a1\3\2")
        buf.write("\2\2\u02a3\u02a4\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5")
        buf.write("\3\2\2\2\u02a5\u02a6\3\2\2\2\u02a6\u02a7\7\6\2\2\u02a7")
        buf.write("\u02a8\7\6\2\2\u02a8\u02aa\3\2\2\2\u02a9\u028f\3\2\2\2")
        buf.write("\u02a9\u0297\3\2\2\2\u02aaQ\3\2\2\2\u02ab\u02ac\7\5\2")
        buf.write("\2\u02ac\u02ad\5\20\t\2\u02ad\u02b1\7\5\2\2\u02ae\u02b0")
        buf.write("\5\62\32\2\u02af\u02ae\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1")
        buf.write("\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b4\3\2\2\2")
        buf.write("\u02b3\u02b1\3\2\2\2\u02b4\u02b5\7\6\2\2\u02b5\u02b6\5")
        buf.write(",\27\2\u02b6\u02b7\7\6\2\2\u02b7S\3\2\2\2\u02b8\u02b9")
        buf.write("\5\20\t\2\u02b9\u02bd\7\5\2\2\u02ba\u02bc\5\62\32\2\u02bb")
        buf.write("\u02ba\3\2\2\2\u02bc\u02bf\3\2\2\2\u02bd\u02bb\3\2\2\2")
        buf.write("\u02bd\u02be\3\2\2\2\u02be\u02c0\3\2\2\2\u02bf\u02bd\3")
        buf.write("\2\2\2\u02c0\u02c1\7\6\2\2\u02c1\u02c2\5,\27\2\u02c2\u02c3")
        buf.write("\58\35\2\u02c3U\3\2\2\2\u02c4\u02cb\5\20\t\2\u02c5\u02c6")
        buf.write("\7\5\2\2\u02c6\u02c7\7\13\2\2\u02c7\u02c8\5\20\t\2\u02c8")
        buf.write("\u02c9\7\6\2\2\u02c9\u02cb\3\2\2\2\u02ca\u02c4\3\2\2\2")
        buf.write("\u02ca\u02c5\3\2\2\2\u02cbW\3\2\2\2\u02cc\u02ce\5\u00c6")
        buf.write("d\2\u02cd\u02cc\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf\u02cd")
        buf.write("\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0Y\3\2\2\2\u02d1\u02cf")
        buf.write("\3\2\2\2\u02d2\u02d3\7\35\2\2\u02d3[\3\2\2\2\u02d4\u02d5")
        buf.write("\7\36\2\2\u02d5]\3\2\2\2\u02d6\u02d7\7\37\2\2\u02d7_\3")
        buf.write("\2\2\2\u02d8\u02d9\7 \2\2\u02d9a\3\2\2\2\u02da\u02db\7")
        buf.write('!\2\2\u02dbc\3\2\2\2\u02dc\u02dd\7"\2\2\u02dde\3\2\2')
        buf.write("\2\u02de\u02df\7$\2\2\u02dfg\3\2\2\2\u02e0\u02e1\7%\2")
        buf.write("\2\u02e1i\3\2\2\2\u02e2\u02e3\7&\2\2\u02e3k\3\2\2\2\u02e4")
        buf.write("\u02e5\7'\2\2\u02e5m\3\2\2\2\u02e6\u02e7\7(\2\2\u02e7")
        buf.write("o\3\2\2\2\u02e8\u02e9\7)\2\2\u02e9q\3\2\2\2\u02ea\u02eb")
        buf.write("\7*\2\2\u02ebs\3\2\2\2\u02ec\u02ed\7+\2\2\u02edu\3\2\2")
        buf.write("\2\u02ee\u02ef\7,\2\2\u02efw\3\2\2\2\u02f0\u02f1\7-\2")
        buf.write("\2\u02f1y\3\2\2\2\u02f2\u02f3\7.\2\2\u02f3{\3\2\2\2\u02f4")
        buf.write("\u02f5\7/\2\2\u02f5}\3\2\2\2\u02f6\u02f7\7\60\2\2\u02f7")
        buf.write("\177\3\2\2\2\u02f8\u02f9\7\61\2\2\u02f9\u0081\3\2\2\2")
        buf.write("\u02fa\u02fb\7\62\2\2\u02fb\u0083\3\2\2\2\u02fc\u02fd")
        buf.write("\7\63\2\2\u02fd\u0085\3\2\2\2\u02fe\u02ff\7\64\2\2\u02ff")
        buf.write("\u0087\3\2\2\2\u0300\u0301\7\65\2\2\u0301\u0089\3\2\2")
        buf.write("\2\u0302\u0303\7\66\2\2\u0303\u008b\3\2\2\2\u0304\u0305")
        buf.write("\7\67\2\2\u0305\u008d\3\2\2\2\u0306\u0307\78\2\2\u0307")
        buf.write("\u008f\3\2\2\2\u0308\u0309\79\2\2\u0309\u0091\3\2\2\2")
        buf.write("\u030a\u030b\7:\2\2\u030b\u0093\3\2\2\2\u030c\u030d\7")
        buf.write(";\2\2\u030d\u0095\3\2\2\2\u030e\u030f\7<\2\2\u030f\u0097")
        buf.write("\3\2\2\2\u0310\u0311\7=\2\2\u0311\u0099\3\2\2\2\u0312")
        buf.write("\u0313\7?\2\2\u0313\u009b\3\2\2\2\u0314\u0315\7@\2\2\u0315")
        buf.write("\u009d\3\2\2\2\u0316\u0317\7#\2\2\u0317\u009f\3\2\2\2")
        buf.write("\u0318\u0319\7A\2\2\u0319\u00a1\3\2\2\2\u031a\u031b\7")
        buf.write("B\2\2\u031b\u00a3\3\2\2\2\u031c\u031d\7C\2\2\u031d\u00a5")
        buf.write("\3\2\2\2\u031e\u031f\7>\2\2\u031f\u00a7\3\2\2\2\u0320")
        buf.write("\u0321\7D\2\2\u0321\u00a9\3\2\2\2\u0322\u0323\7E\2\2\u0323")
        buf.write("\u00ab\3\2\2\2\u0324\u0325\7F\2\2\u0325\u00ad\3\2\2\2")
        buf.write("\u0326\u0327\7G\2\2\u0327\u00af\3\2\2\2\u0328\u0329\7")
        buf.write("H\2\2\u0329\u00b1\3\2\2\2\u032a\u032b\7I\2\2\u032b\u00b3")
        buf.write("\3\2\2\2\u032c\u032d\7J\2\2\u032d\u00b5\3\2\2\2\u032e")
        buf.write("\u032f\7K\2\2\u032f\u00b7\3\2\2\2\u0330\u0331\7L\2\2\u0331")
        buf.write("\u00b9\3\2\2\2\u0332\u0333\7M\2\2\u0333\u00bb\3\2\2\2")
        buf.write("\u0334\u0335\7N\2\2\u0335\u00bd\3\2\2\2\u0336\u0337\7")
        buf.write("O\2\2\u0337\u00bf\3\2\2\2\u0338\u0339\7P\2\2\u0339\u00c1")
        buf.write("\3\2\2\2\u033a\u033b\7Q\2\2\u033b\u00c3\3\2\2\2\u033c")
        buf.write("\u0399\5&\24\2\u033d\u0399\7\37\2\2\u033e\u033f\7\5\2")
        buf.write("\2\u033f\u0340\7R\2\2\u0340\u0342\5\u00c4c\2\u0341\u0343")
        buf.write("\5*\26\2\u0342\u0341\3\2\2\2\u0342\u0343\3\2\2\2\u0343")
        buf.write("\u0344\3\2\2\2\u0344\u0345\7\6\2\2\u0345\u0399\3\2\2\2")
        buf.write("\u0346\u0347\7\5\2\2\u0347\u0349\5\u00b4[\2\u0348\u034a")
        buf.write("\5\u00c4c\2\u0349\u0348\3\2\2\2\u034a\u034b\3\2\2\2\u034b")
        buf.write("\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u034d\3\2\2\2")
        buf.write("\u034d\u034e\7\6\2\2\u034e\u0399\3\2\2\2\u034f\u0350\7")
        buf.write("\5\2\2\u0350\u0352\5\u00b6\\\2\u0351\u0353\5\u00c4c\2")
        buf.write("\u0352\u0351\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0352\3")
        buf.write("\2\2\2\u0354\u0355\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0357")
        buf.write("\7\6\2\2\u0357\u0399\3\2\2\2\u0358\u0359\7\5\2\2\u0359")
        buf.write("\u035b\5\u00b8]\2\u035a\u035c\5\u00c4c\2\u035b\u035a\3")
        buf.write("\2\2\2\u035c\u035d\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035e")
        buf.write("\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0360\5\u00c4c\2\u0360")
        buf.write("\u0361\7\6\2\2\u0361\u0399\3\2\2\2\u0362\u0363\7\5\2\2")
        buf.write("\u0363\u0365\5\u00ba^\2\u0364\u0366\5\u00c4c\2\u0365\u0364")
        buf.write("\3\2\2\2\u0366\u0367\3\2\2\2\u0367\u0365\3\2\2\2\u0367")
        buf.write("\u0368\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036a\5\u00c4")
        buf.write("c\2\u036a\u036b\7\6\2\2\u036b\u0399\3\2\2\2\u036c\u036d")
        buf.write("\7\5\2\2\u036d\u036f\5\u00bc_\2\u036e\u0370\5\u00c4c\2")
        buf.write("\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u036f\3")
        buf.write("\2\2\2\u0371\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374")
        buf.write("\7\6\2\2\u0374\u0399\3\2\2\2\u0375\u0376\7\5\2\2\u0376")
        buf.write("\u0378\5\u00be`\2\u0377\u0379\5\u00c4c\2\u0378\u0377\3")
        buf.write("\2\2\2\u0379\u037a\3\2\2\2\u037a\u0378\3\2\2\2\u037a\u037b")
        buf.write("\3\2\2\2\u037b\u037c\3\2\2\2\u037c\u037d\7\6\2\2\u037d")
        buf.write("\u0399\3\2\2\2\u037e\u037f\7\5\2\2\u037f\u0381\5\u00c0")
        buf.write("a\2\u0380\u0382\5\u00c4c\2\u0381\u0380\3\2\2\2\u0382\u0383")
        buf.write("\3\2\2\2\u0383\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384")
        buf.write("\u0385\3\2\2\2\u0385\u0386\5\24\13\2\u0386\u0387\7\6\2")
        buf.write("\2\u0387\u0399\3\2\2\2\u0388\u0389\7\5\2\2\u0389\u038a")
        buf.write("\5\u00c2b\2\u038a\u038b\5\u00c4c\2\u038b\u038c\5*\26\2")
        buf.write("\u038c\u038d\7\6\2\2\u038d\u0399\3\2\2\2\u038e\u038f\7")
        buf.write("\5\2\2\u038f\u0392\5\u0086D\2\u0390\u0393\5\32\16\2\u0391")
        buf.write("\u0393\5\20\t\2\u0392\u0390\3\2\2\2\u0392\u0391\3\2\2")
        buf.write("\2\u0393\u0394\3\2\2\2\u0394\u0392\3\2\2\2\u0394\u0395")
        buf.write("\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0397\7\6\2\2\u0397")
        buf.write("\u0399\3\2\2\2\u0398\u033c\3\2\2\2\u0398\u033d\3\2\2\2")
        buf.write("\u0398\u033e\3\2\2\2\u0398\u0346\3\2\2\2\u0398\u034f\3")
        buf.write("\2\2\2\u0398\u0358\3\2\2\2\u0398\u0362\3\2\2\2\u0398\u036c")
        buf.write("\3\2\2\2\u0398\u0375\3\2\2\2\u0398\u037e\3\2\2\2\u0398")
        buf.write("\u0388\3\2\2\2\u0398\u038e\3\2\2\2\u0399\u00c5\3\2\2\2")
        buf.write("\u039a\u039b\7\5\2\2\u039b\u039c\5Z.\2\u039c\u039d\58")
        buf.write("\35\2\u039d\u039e\7\6\2\2\u039e\u04df\3\2\2\2\u039f\u03a0")
        buf.write("\7\5\2\2\u03a0\u03a1\5\\/\2\u03a1\u03a5\58\35\2\u03a2")
        buf.write("\u03a4\5*\26\2\u03a3\u03a2\3\2\2\2\u03a4\u03a7\3\2\2\2")
        buf.write("\u03a5\u03a3\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a8\3")
        buf.write("\2\2\2\u03a7\u03a5\3\2\2\2\u03a8\u03a9\7\6\2\2\u03a9\u04df")
        buf.write("\3\2\2\2\u03aa\u03ab\7\5\2\2\u03ab\u03af\5`\61\2\u03ac")
        buf.write("\u03ae\58\35\2\u03ad\u03ac\3\2\2\2\u03ae\u03b1\3\2\2\2")
        buf.write("\u03af\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03b2\3")
        buf.write("\2\2\2\u03b1\u03af\3\2\2\2\u03b2\u03b3\7\6\2\2\u03b3\u04df")
        buf.write("\3\2\2\2\u03b4\u03b5\7\5\2\2\u03b5\u03b6\5b\62\2\u03b6")
        buf.write("\u03ba\7\5\2\2\u03b7\u03b9\58\35\2\u03b8\u03b7\3\2\2\2")
        buf.write("\u03b9\u03bc\3\2\2\2\u03ba\u03b8\3\2\2\2\u03ba\u03bb\3")
        buf.write("\2\2\2\u03bb\u03bd\3\2\2\2\u03bc\u03ba\3\2\2\2\u03bd\u03be")
        buf.write("\7\6\2\2\u03be\u03bf\7\6\2\2\u03bf\u04df\3\2\2\2\u03c0")
        buf.write("\u03c1\7\5\2\2\u03c1\u03c2\5f\64\2\u03c2\u03c3\58\35\2")
        buf.write("\u03c3\u03c4\7\6\2\2\u03c4\u04df\3\2\2\2\u03c5\u03c6\7")
        buf.write("\5\2\2\u03c6\u03c7\5h\65\2\u03c7\u03c8\58\35\2\u03c8\u03c9")
        buf.write("\7\6\2\2\u03c9\u04df\3\2\2\2\u03ca\u03cb\7\5\2\2\u03cb")
        buf.write("\u03cc\5^\60\2\u03cc\u03d0\58\35\2\u03cd\u03cf\5*\26\2")
        buf.write("\u03ce\u03cd\3\2\2\2\u03cf\u03d2\3\2\2\2\u03d0\u03ce\3")
        buf.write("\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03d3\3\2\2\2\u03d2\u03d0")
        buf.write("\3\2\2\2\u03d3\u03d4\7\6\2\2\u03d4\u04df\3\2\2\2\u03d5")
        buf.write("\u03d6\7\5\2\2\u03d6\u03d7\5j\66\2\u03d7\u03d8\5\20\t")
        buf.write("\2\u03d8\u03d9\5,\27\2\u03d9\u03da\7\6\2\2\u03da\u04df")
        buf.write("\3\2\2\2\u03db\u03dc\7\5\2\2\u03dc\u03dd\5l\67\2\u03dd")
        buf.write("\u03de\5\20\t\2\u03de\u03df\5P)\2\u03df\u03e0\7\6\2\2")
        buf.write("\u03e0\u04df\3\2\2\2\u03e1\u03e2\7\5\2\2\u03e2\u03e3\5")
        buf.write("n8\2\u03e3\u03e4\5\20\t\2\u03e4\u03e5\5P)\2\u03e5\u03e6")
        buf.write("\7\6\2\2\u03e6\u04df\3\2\2\2\u03e7\u03e8\7\5\2\2\u03e8")
        buf.write("\u03e9\5p9\2\u03e9\u03eb\7\5\2\2\u03ea\u03ec\5J&\2\u03eb")
        buf.write("\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u03eb\3\2\2\2")
        buf.write("\u03ed\u03ee\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\7")
        buf.write("\6\2\2\u03f0\u03f2\7\5\2\2\u03f1\u03f3\5P)\2\u03f2\u03f1")
        buf.write("\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f2\3\2\2\2\u03f4")
        buf.write("\u03f5\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f7\7\6\2\2")
        buf.write("\u03f7\u03f8\7\6\2\2\u03f8\u04df\3\2\2\2\u03f9\u03fa\7")
        buf.write("\5\2\2\u03fa\u03fb\5r:\2\u03fb\u03fd\7\5\2\2\u03fc\u03fe")
        buf.write("\5J&\2\u03fd\u03fc\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u03fd")
        buf.write("\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0401\3\2\2\2\u0401")
        buf.write("\u0402\7\6\2\2\u0402\u0403\5P)\2\u0403\u0404\7\6\2\2\u0404")
        buf.write("\u0406\7\5\2\2\u0405\u0407\5P)\2\u0406\u0405\3\2\2\2\u0407")
        buf.write("\u0408\3\2\2\2\u0408\u0406\3\2\2\2\u0408\u0409\3\2\2\2")
        buf.write("\u0409\u040a\3\2\2\2\u040a\u040b\7\6\2\2\u040b\u040c\7")
        buf.write("\6\2\2\u040c\u04df\3\2\2\2\u040d\u040e\7\5\2\2\u040e\u040f")
        buf.write("\5t;\2\u040f\u0410\5\20\t\2\u0410\u0414\7\5\2\2\u0411")
        buf.write("\u0413\5,\27\2\u0412\u0411\3\2\2\2\u0413\u0416\3\2\2\2")
        buf.write("\u0414\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0417\3")
        buf.write("\2\2\2\u0416\u0414\3\2\2\2\u0417\u0418\7\6\2\2\u0418\u0419")
        buf.write("\5,\27\2\u0419\u041a\7\6\2\2\u041a\u04df\3\2\2\2\u041b")
        buf.write("\u041c\7\5\2\2\u041c\u041d\5v<\2\u041d\u041f\5\20\t\2")
        buf.write("\u041e\u0420\5\22\n\2\u041f\u041e\3\2\2\2\u041f\u0420")
        buf.write("\3\2\2\2\u0420\u0421\3\2\2\2\u0421\u0422\7\6\2\2\u0422")
        buf.write("\u04df\3\2\2\2\u0423\u0424\7\5\2\2\u0424\u0425\5x=\2\u0425")
        buf.write("\u0426\5\20\t\2\u0426\u0427\58\35\2\u0427\u0428\7\6\2")
        buf.write("\2\u0428\u04df\3\2\2\2\u0429\u042a\7\5\2\2\u042a\u042b")
        buf.write("\5z>\2\u042b\u042c\5T+\2\u042c\u042d\7\6\2\2\u042d\u04df")
        buf.write("\3\2\2\2\u042e\u042f\7\5\2\2\u042f\u0430\5|?\2\u0430\u0431")
        buf.write("\5\20\t\2\u0431\u0432\5,\27\2\u0432\u0433\58\35\2\u0433")
        buf.write("\u0434\7\6\2\2\u0434\u04df\3\2\2\2\u0435\u0436\7\5\2\2")
        buf.write("\u0436\u0437\5~@\2\u0437\u0438\5T+\2\u0438\u0439\7\6\2")
        buf.write("\2\u0439\u04df\3\2\2\2\u043a\u043b\7\5\2\2\u043b\u043c")
        buf.write("\5\u0080A\2\u043c\u043e\7\5\2\2\u043d\u043f\5R*\2\u043e")
        buf.write("\u043d\3\2\2\2\u043f\u0440\3\2\2\2\u0440\u043e\3\2\2\2")
        buf.write("\u0440\u0441\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0443\7")
        buf.write("\6\2\2\u0443\u0445\7\5\2\2\u0444\u0446\58\35\2\u0445\u0444")
        buf.write("\3\2\2\2\u0446\u0447\3\2\2\2\u0447\u0445\3\2\2\2\u0447")
        buf.write("\u0448\3\2\2\2\u0448\u0449\3\2\2\2\u0449\u044a\7\6\2\2")
        buf.write("\u044a\u044b\7\6\2\2\u044b\u04df\3\2\2\2\u044c\u044d\7")
        buf.write("\5\2\2\u044d\u044e\5\u0084C\2\u044e\u044f\58\35\2\u044f")
        buf.write("\u0450\7\6\2\2\u0450\u04df\3\2\2\2\u0451\u0452\7\5\2\2")
        buf.write("\u0452\u0453\5\u0082B\2\u0453\u0454\5\20\t\2\u0454\u0458")
        buf.write("\7\5\2\2\u0455\u0457\5\20\t\2\u0456\u0455\3\2\2\2\u0457")
        buf.write("\u045a\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0459\3\2\2\2")
        buf.write("\u0459\u045b\3\2\2\2\u045a\u0458\3\2\2\2\u045b\u045c\7")
        buf.write("\6\2\2\u045c\u045d\5,\27\2\u045d\u045e\7\6\2\2\u045e\u04df")
        buf.write("\3\2\2\2\u045f\u0460\7\5\2\2\u0460\u0463\5\u0086D\2\u0461")
        buf.write("\u0464\5\32\16\2\u0462\u0464\5\20\t\2\u0463\u0461\3\2")
        buf.write("\2\2\u0463\u0462\3\2\2\2\u0464\u0465\3\2\2\2\u0465\u0463")
        buf.write("\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u0467\3\2\2\2\u0467")
        buf.write("\u0468\7\6\2\2\u0468\u04df\3\2\2\2\u0469\u046a\7\5\2\2")
        buf.write("\u046a\u046b\5\u0088E\2\u046b\u046c\58\35\2\u046c\u046d")
        buf.write("\7\6\2\2\u046d\u04df\3\2\2\2\u046e\u046f\7\5\2\2\u046f")
        buf.write("\u0470\5\u008aF\2\u0470\u0471\7\6\2\2\u0471\u04df\3\2")
        buf.write("\2\2\u0472\u0473\7\5\2\2\u0473\u0474\5\u008cG\2\u0474")
        buf.write("\u0475\7\6\2\2\u0475\u04df\3\2\2\2\u0476\u0477\7\5\2\2")
        buf.write("\u0477\u0478\5\u008eH\2\u0478\u0479\7\6\2\2\u0479\u04df")
        buf.write("\3\2\2\2\u047a\u047b\7\5\2\2\u047b\u047c\5\u0090I\2\u047c")
        buf.write("\u047d\7\6\2\2\u047d\u04df\3\2\2\2\u047e\u047f\7\5\2\2")
        buf.write("\u047f\u0480\5\u0092J\2\u0480\u0481\5\u00ccg\2\u0481\u0482")
        buf.write("\7\6\2\2\u0482\u04df\3\2\2\2\u0483\u0484\7\5\2\2\u0484")
        buf.write("\u0485\5\u0094K\2\u0485\u0486\7\6\2\2\u0486\u04df\3\2")
        buf.write("\2\2\u0487\u0488\7\5\2\2\u0488\u0489\5\u0096L\2\u0489")
        buf.write("\u048a\7\6\2\2\u048a\u04df\3\2\2\2\u048b\u048c\7\5\2\2")
        buf.write("\u048c\u048d\5\u0098M\2\u048d\u048e\5\36\20\2\u048e\u048f")
        buf.write("\7\6\2\2\u048f\u04df\3\2\2\2\u0490\u0491\7\5\2\2\u0491")
        buf.write("\u0492\5\u009aN\2\u0492\u0493\7\6\2\2\u0493\u04df\3\2")
        buf.write("\2\2\u0494\u0495\7\5\2\2\u0495\u0496\5\u009cO\2\u0496")
        buf.write("\u0497\7\6\2\2\u0497\u04df\3\2\2\2\u0498\u0499\7\5\2\2")
        buf.write("\u0499\u049a\5\u00a0Q\2\u049a\u049b\7\6\2\2\u049b\u04df")
        buf.write("\3\2\2\2\u049c\u049d\7\5\2\2\u049d\u049e\5\u00a2R\2\u049e")
        buf.write("\u04a0\7\5\2\2\u049f\u04a1\58\35\2\u04a0\u049f\3\2\2\2")
        buf.write("\u04a1\u04a2\3\2\2\2\u04a2\u04a0\3\2\2\2\u04a2\u04a3\3")
        buf.write("\2\2\2\u04a3\u04a4\3\2\2\2\u04a4\u04a5\7\6\2\2\u04a5\u04a6")
        buf.write("\7\6\2\2\u04a6\u04df\3\2\2\2\u04a7\u04a8\7\5\2\2\u04a8")
        buf.write("\u04a9\5\u00a6T\2\u04a9\u04aa\58\35\2\u04aa\u04ab\7\6")
        buf.write("\2\2\u04ab\u04df\3\2\2\2\u04ac\u04ad\7\5\2\2\u04ad\u04ae")
        buf.write("\5\u00a4S\2\u04ae\u04af\5\22\n\2\u04af\u04b0\7\6\2\2\u04b0")
        buf.write("\u04df\3\2\2\2\u04b1\u04b2\7\5\2\2\u04b2\u04b3\5\u00a4")
        buf.write("S\2\u04b3\u04b4\7\6\2\2\u04b4\u04df\3\2\2\2\u04b5\u04b6")
        buf.write("\7\5\2\2\u04b6\u04b7\5\u00a8U\2\u04b7\u04b8\5\22\n\2\u04b8")
        buf.write("\u04b9\7\6\2\2\u04b9\u04df\3\2\2\2\u04ba\u04bb\7\5\2\2")
        buf.write("\u04bb\u04bc\5\u00a8U\2\u04bc\u04bd\7\6\2\2\u04bd\u04df")
        buf.write("\3\2\2\2\u04be\u04bf\7\5\2\2\u04bf\u04c0\5\u00aaV\2\u04c0")
        buf.write("\u04c1\7\6\2\2\u04c1\u04df\3\2\2\2\u04c2\u04c3\7\5\2\2")
        buf.write("\u04c3\u04c4\5\u00acW\2\u04c4\u04c5\7\6\2\2\u04c5\u04df")
        buf.write("\3\2\2\2\u04c6\u04c7\7\5\2\2\u04c7\u04c8\5\u00aeX\2\u04c8")
        buf.write("\u04c9\5*\26\2\u04c9\u04ca\7\6\2\2\u04ca\u04df\3\2\2\2")
        buf.write("\u04cb\u04cc\7\5\2\2\u04cc\u04cd\5\u00b0Y\2\u04cd\u04ce")
        buf.write("\5\20\t\2\u04ce\u04cf\7\6\2\2\u04cf\u04df\3\2\2\2\u04d0")
        buf.write("\u04d1\7\5\2\2\u04d1\u04d2\5\u00b2Z\2\u04d2\u04d3\5\u00ca")
        buf.write("f\2\u04d3\u04d4\7\6\2\2\u04d4\u04df\3\2\2\2\u04d5\u04d6")
        buf.write("\7\5\2\2\u04d6\u04d7\5d\63\2\u04d7\u04d8\5\u00c4c\2\u04d8")
        buf.write("\u04d9\7\6\2\2\u04d9\u04df\3\2\2\2\u04da\u04db\7\5\2\2")
        buf.write("\u04db\u04dc\5\u009eP\2\u04dc\u04dd\7\6\2\2\u04dd\u04df")
        buf.write("\3\2\2\2\u04de\u039a\3\2\2\2\u04de\u039f\3\2\2\2\u04de")
        buf.write("\u03aa\3\2\2\2\u04de\u03b4\3\2\2\2\u04de\u03c0\3\2\2\2")
        buf.write("\u04de\u03c5\3\2\2\2\u04de\u03ca\3\2\2\2\u04de\u03d5\3")
        buf.write("\2\2\2\u04de\u03db\3\2\2\2\u04de\u03e1\3\2\2\2\u04de\u03e7")
        buf.write("\3\2\2\2\u04de\u03f9\3\2\2\2\u04de\u040d\3\2\2\2\u04de")
        buf.write("\u041b\3\2\2\2\u04de\u0423\3\2\2\2\u04de\u0429\3\2\2\2")
        buf.write("\u04de\u042e\3\2\2\2\u04de\u0435\3\2\2\2\u04de\u043a\3")
        buf.write("\2\2\2\u04de\u044c\3\2\2\2\u04de\u0451\3\2\2\2\u04de\u045f")
        buf.write("\3\2\2\2\u04de\u0469\3\2\2\2\u04de\u046e\3\2\2\2\u04de")
        buf.write("\u0472\3\2\2\2\u04de\u0476\3\2\2\2\u04de\u047a\3\2\2\2")
        buf.write("\u04de\u047e\3\2\2\2\u04de\u0483\3\2\2\2\u04de\u0487\3")
        buf.write("\2\2\2\u04de\u048b\3\2\2\2\u04de\u0490\3\2\2\2\u04de\u0494")
        buf.write("\3\2\2\2\u04de\u0498\3\2\2\2\u04de\u049c\3\2\2\2\u04de")
        buf.write("\u04a7\3\2\2\2\u04de\u04ac\3\2\2\2\u04de\u04b1\3\2\2\2")
        buf.write("\u04de\u04b5\3\2\2\2\u04de\u04ba\3\2\2\2\u04de\u04be\3")
        buf.write("\2\2\2\u04de\u04c2\3\2\2\2\u04de\u04c6\3\2\2\2\u04de\u04cb")
        buf.write("\3\2\2\2\u04de\u04d0\3\2\2\2\u04de\u04d5\3\2\2\2\u04de")
        buf.write("\u04da\3\2\2\2\u04df\u00c7\3\2\2\2\u04e0\u04e1\t\6\2\2")
        buf.write("\u04e1\u00c9\3\2\2\2\u04e2\u04e3\7i\2\2\u04e3\u0500\5")
        buf.write("\32\16\2\u04e4\u04e5\7n\2\2\u04e5\u0500\5\u00c8e\2\u04e6")
        buf.write("\u04e7\7o\2\2\u04e7\u0500\5\u00c8e\2\u04e8\u04e9\7w\2")
        buf.write("\2\u04e9\u0500\5\u00c8e\2\u04ea\u04eb\7x\2\2\u04eb\u0500")
        buf.write("\5\u00c8e\2\u04ec\u04ed\7y\2\2\u04ed\u0500\5\u00c8e\2")
        buf.write("\u04ee\u04ef\7z\2\2\u04ef\u0500\5\u00c8e\2\u04f0\u04f1")
        buf.write("\7{\2\2\u04f1\u0500\5\u00c8e\2\u04f2\u04f3\7|\2\2\u04f3")
        buf.write("\u0500\5\u00c8e\2\u04f4\u04f5\7}\2\2\u04f5\u0500\5\u00c8")
        buf.write("e\2\u04f6\u04f7\7~\2\2\u04f7\u0500\5\22\n\2\u04f8\u04f9")
        buf.write("\7\u0080\2\2\u04f9\u0500\5\32\16\2\u04fa\u04fb\7\u0081")
        buf.write("\2\2\u04fb\u0500\5\22\n\2\u04fc\u04fd\7\u008a\2\2\u04fd")
        buf.write("\u0500\5\22\n\2\u04fe\u0500\5*\26\2\u04ff\u04e2\3\2\2")
        buf.write("\2\u04ff\u04e4\3\2\2\2\u04ff\u04e6\3\2\2\2\u04ff\u04e8")
        buf.write("\3\2\2\2\u04ff\u04ea\3\2\2\2\u04ff\u04ec\3\2\2\2\u04ff")
        buf.write("\u04ee\3\2\2\2\u04ff\u04f0\3\2\2\2\u04ff\u04f2\3\2\2\2")
        buf.write("\u04ff\u04f4\3\2\2\2\u04ff\u04f6\3\2\2\2\u04ff\u04f8\3")
        buf.write("\2\2\2\u04ff\u04fa\3\2\2\2\u04ff\u04fc\3\2\2\2\u04ff\u04fe")
        buf.write("\3\2\2\2\u0500\u00cb\3\2\2\2\u0501\u050a\7c\2\2\u0502")
        buf.write("\u050a\7d\2\2\u0503\u050a\7e\2\2\u0504\u050a\7j\2\2\u0505")
        buf.write("\u050a\7t\2\2\u0506\u050a\7\177\2\2\u0507\u050a\7\u008b")
        buf.write("\2\2\u0508\u050a\5\36\20\2\u0509\u0501\3\2\2\2\u0509\u0502")
        buf.write("\3\2\2\2\u0509\u0503\3\2\2\2\u0509\u0504\3\2\2\2\u0509")
        buf.write("\u0505\3\2\2\2\u0509\u0506\3\2\2\2\u0509\u0507\3\2\2\2")
        buf.write("\u0509\u0508\3\2\2\2\u050a\u00cd\3\2\2\2\u050b\u050c\t")
        buf.write("\7\2\2\u050c\u00cf\3\2\2\2\u050d\u0511\7\25\2\2\u050e")
        buf.write('\u0511\7\23\2\2\u050f\u0511\5"\22\2\u0510\u050d\3\2\2')
        buf.write("\2\u0510\u050e\3\2\2\2\u0510\u050f\3\2\2\2\u0511\u00d1")
        buf.write("\3\2\2\2\u0512\u0513\7\5\2\2\u0513\u0514\7.\2\2\u0514")
        buf.write("\u0515\5T+\2\u0515\u0516\7\6\2\2\u0516\u052f\3\2\2\2\u0517")
        buf.write("\u0518\7\5\2\2\u0518\u0519\7\60\2\2\u0519\u051a\5T+\2")
        buf.write("\u051a\u051b\7\6\2\2\u051b\u052f\3\2\2\2\u051c\u051d\7")
        buf.write("\5\2\2\u051d\u051e\7\61\2\2\u051e\u0520\7\5\2\2\u051f")
        buf.write("\u0521\5R*\2\u0520\u051f\3\2\2\2\u0521\u0522\3\2\2\2\u0522")
        buf.write("\u0520\3\2\2\2\u0522\u0523\3\2\2\2\u0523\u0524\3\2\2\2")
        buf.write("\u0524\u0525\7\6\2\2\u0525\u0527\7\5\2\2\u0526\u0528\5")
        buf.write("8\35\2\u0527\u0526\3\2\2\2\u0528\u0529\3\2\2\2\u0529\u0527")
        buf.write("\3\2\2\2\u0529\u052a\3\2\2\2\u052a\u052b\3\2\2\2\u052b")
        buf.write("\u052c\7\6\2\2\u052c\u052d\7\6\2\2\u052d\u052f\3\2\2\2")
        buf.write("\u052e\u0512\3\2\2\2\u052e\u0517\3\2\2\2\u052e\u051c\3")
        buf.write("\2\2\2\u052f\u00d3\3\2\2\2\u0530\u0531\7d\2\2\u0531\u053e")
        buf.write("\5\22\n\2\u0532\u0533\7e\2\2\u0533\u053e\5\32\16\2\u0534")
        buf.write("\u0535\7j\2\2\u0535\u053e\5\u00ceh\2\u0536\u0537\7t\2")
        buf.write("\2\u0537\u053e\5\32\16\2\u0538\u0539\7\177\2\2\u0539\u053e")
        buf.write("\5\u00d0i\2\u053a\u053b\7\u008b\2\2\u053b\u053e\5\32\16")
        buf.write("\2\u053c\u053e\5*\26\2\u053d\u0530\3\2\2\2\u053d\u0532")
        buf.write("\3\2\2\2\u053d\u0534\3\2\2\2\u053d\u0536\3\2\2\2\u053d")
        buf.write("\u0538\3\2\2\2\u053d\u053a\3\2\2\2\u053d\u053c\3\2\2\2")
        buf.write("\u053e\u00d5\3\2\2\2\u053f\u0540\7\5\2\2\u0540\u0541\5")
        buf.write("8\35\2\u0541\u0542\58\35\2\u0542\u0543\7\6\2\2\u0543\u00d7")
        buf.write("\3\2\2\2\u0544\u0545\7\5\2\2\u0545\u0546\5\20\t\2\u0546")
        buf.write("\u0547\5\u00c8e\2\u0547\u0548\7\6\2\2\u0548\u00d9\3\2")
        buf.write("\2\2\u0549\u054a\t\b\2\2\u054a\u00db\3\2\2\2\u054b\u054c")
        buf.write("\5\32\16\2\u054c\u00dd\3\2\2\2\u054d\u0551\7\5\2\2\u054e")
        buf.write("\u0550\58\35\2\u054f\u054e\3\2\2\2\u0550\u0553\3\2\2\2")
        buf.write("\u0551\u054f\3\2\2\2\u0551\u0552\3\2\2\2\u0552\u0554\3")
        buf.write("\2\2\2\u0553\u0551\3\2\2\2\u0554\u0555\7\6\2\2\u0555\u00df")
        buf.write("\3\2\2\2\u0556\u055a\7\5\2\2\u0557\u0559\5\u00d8m\2\u0558")
        buf.write("\u0557\3\2\2\2\u0559\u055c\3\2\2\2\u055a\u0558\3\2\2\2")
        buf.write("\u055a\u055b\3\2\2\2\u055b\u055d\3\2\2\2\u055c\u055a\3")
        buf.write("\2\2\2\u055d\u055e\7\6\2\2\u055e\u00e1\3\2\2\2\u055f\u0561")
        buf.write("\7\5\2\2\u0560\u0562\5\u00d4k\2\u0561\u0560\3\2\2\2\u0562")
        buf.write("\u0563\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2")
        buf.write("\u0564\u0565\3\2\2\2\u0565\u0566\7\6\2\2\u0566\u00e3\3")
        buf.write("\2\2\2\u0567\u056b\7\5\2\2\u0568\u056a\5\u00d2j\2\u0569")
        buf.write("\u0568\3\2\2\2\u056a\u056d\3\2\2\2\u056b\u0569\3\2\2\2")
        buf.write("\u056b\u056c\3\2\2\2\u056c\u056e\3\2\2\2\u056d\u056b\3")
        buf.write("\2\2\2\u056e\u056f\7\6\2\2\u056f\u00e5\3\2\2\2\u0570\u0571")
        buf.write('\5(\25\2\u0571\u00e7\3\2\2\2\u0572\u0573\5"\22\2\u0573')
        buf.write("\u00e9\3\2\2\2\u0574\u0578\7\5\2\2\u0575\u0577\5\20\t")
        buf.write("\2\u0576\u0575\3\2\2\2\u0577\u057a\3\2\2\2\u0578\u0576")
        buf.write("\3\2\2\2\u0578\u0579\3\2\2\2\u0579\u057b\3\2\2\2\u057a")
        buf.write("\u0578\3\2\2\2\u057b\u057c\7\6\2\2\u057c\u00eb\3\2\2\2")
        buf.write("\u057d\u0581\7\5\2\2\u057e\u0580\5\20\t\2\u057f\u057e")
        buf.write("\3\2\2\2\u0580\u0583\3\2\2\2\u0581\u057f\3\2\2\2\u0581")
        buf.write("\u0582\3\2\2\2\u0582\u0584\3\2\2\2\u0583\u0581\3\2\2\2")
        buf.write("\u0584\u0585\7\6\2\2\u0585\u00ed\3\2\2\2\u0586\u0588\7")
        buf.write("\5\2\2\u0587\u0589\5\u00d6l\2\u0588\u0587\3\2\2\2\u0589")
        buf.write("\u058a\3\2\2\2\u058a\u0588\3\2\2\2\u058a\u058b\3\2\2\2")
        buf.write("\u058b\u058c\3\2\2\2\u058c\u058d\7\6\2\2\u058d\u00ef\3")
        buf.write("\2\2\2\u058e\u059a\5\u00dan\2\u058f\u059a\5\u00dco\2\u0590")
        buf.write("\u059a\5\u00dep\2\u0591\u059a\5\u00e0q\2\u0592\u059a\5")
        buf.write("\u00e2r\2\u0593\u059a\5\u00e4s\2\u0594\u059a\5\u00e6t")
        buf.write("\2\u0595\u059a\5\u00e8u\2\u0596\u059a\5\u00eav\2\u0597")
        buf.write("\u059a\5\u00ecw\2\u0598\u059a\5\u00eex\2\u0599\u058e\3")
        buf.write("\2\2\2\u0599\u058f\3\2\2\2\u0599\u0590\3\2\2\2\u0599\u0591")
        buf.write("\3\2\2\2\u0599\u0592\3\2\2\2\u0599\u0593\3\2\2\2\u0599")
        buf.write("\u0594\3\2\2\2\u0599\u0595\3\2\2\2\u0599\u0596\3\2\2\2")
        buf.write("\u0599\u0597\3\2\2\2\u0599\u0598\3\2\2\2\u059a\u00f1\3")
        buf.write("\2\2\2\u059b\u05a4\7\27\2\2\u059c\u05a4\5\u00f0y\2\u059d")
        buf.write("\u05a4\7\33\2\2\u059e\u059f\7\5\2\2\u059f\u05a0\7\20\2")
        buf.write("\2\u05a0\u05a1\5\32\16\2\u05a1\u05a2\7\6\2\2\u05a2\u05a4")
        buf.write("\3\2\2\2\u05a3\u059b\3\2\2\2\u05a3\u059c\3\2\2\2\u05a3")
        buf.write("\u059d\3\2\2\2\u05a3\u059e\3\2\2\2\u05a4\u00f3\3\2\2\2")
        buf.write("a\u00fe\u0108\u0119\u0129\u0132\u0136\u013a\u0143\u0147")
        buf.write("\u014f\u0153\u0159\u0161\u0165\u016e\u0180\u0184\u0198")
        buf.write("\u01a3\u01ae\u01ba\u01c6\u01d3\u01de\u01e2\u01ea\u01f7")
        buf.write("\u0202\u020c\u0211\u0216\u021f\u0227\u022c\u0232\u0239")
        buf.write("\u0242\u0251\u0259\u0262\u026f\u0277\u028a\u0293\u029d")
        buf.write("\u02a4\u02a9\u02b1\u02bd\u02ca\u02cf\u0342\u034b\u0354")
        buf.write("\u035d\u0367\u0371\u037a\u0383\u0392\u0394\u0398\u03a5")
        buf.write("\u03af\u03ba\u03d0\u03ed\u03f4\u03ff\u0408\u0414\u041f")
        buf.write("\u0440\u0447\u0458\u0463\u0465\u04a2\u04de\u04ff\u0509")
        buf.write("\u0510\u0522\u0529\u052e\u053d\u0551\u055a\u0563\u056b")
        buf.write("\u0578\u0581\u058a\u0599\u05a3")
        return buf.getvalue()


class SMTLIBv2Parser(Parser):

    grammarFileName = "SMTLIBv2.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "' bv'",
        "<INVALID>",
        "'('",
        "')'",
        "';'",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "'not'",
        "'Bool'",
        "'Int'",
        "'Real'",
        "'continued-execution'",
        "'error'",
        "'false'",
        "'immediate-exit'",
        "'incomplete'",
        "'logic'",
        "'memout'",
        "'sat'",
        "'success'",
        "'theory'",
        "'true'",
        "'unknown'",
        "'unsupported'",
        "'unsat'",
        "'assert'",
        "'assert-soft'",
        "'simplify'",
        "'check-sat'",
        "'check-sat-assuming'",
        "'check-sat-using'",
        "'labels'",
        "'minimize'",
        "'maximize'",
        "'declare-const'",
        "'declare-datatype'",
        "'declare-codatatype'",
        "'declare-datatypes'",
        "'declare-codatatypes'",
        "'declare-fun'",
        "'declare-sort'",
        "'define'",
        "'define-fun'",
        "'define-const'",
        "'define-fun-rec'",
        "'define-funs-rec'",
        "'define-sort'",
        "'display'",
        "'echo'",
        "'eval'",
        "'exit'",
        "'get-objectives'",
        "'get-assertions'",
        "'get-assignment'",
        "'get-info'",
        "'get-model'",
        "'block-model'",
        "'get-option'",
        "'poly/factor'",
        "'get-proof'",
        "'get-unsat-assumptions'",
        "'get-unsat-core'",
        "'get-value'",
        "'pop'",
        "'push'",
        "'reset'",
        "'reset-assertions'",
        "'set-info'",
        "'set-logic'",
        "'set-option'",
        "'then'",
        "'and-then'",
        "'par-then'",
        "'or-else'",
        "'par-or-else'",
        "'par-or'",
        "'try-for'",
        "'using-params'",
        "'!'",
        "'_'",
        "'as'",
        "'BINARY'",
        "'DECIMAL'",
        "'exists'",
        "'HEXADECIMAL'",
        "'forall'",
        "'let'",
        "'match'",
        "'NUMERAL'",
        "'par'",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "':'",
        "':all-statistics'",
        "':assertion-stack-levels'",
        "':authors'",
        "':category'",
        "':chainable'",
        "':definition'",
        "':diagnostic-output-channel'",
        "':error-behavior'",
        "':extensions'",
        "':funs'",
        "':funs-description'",
        "':global-declarations'",
        "':interactive-mode'",
        "':language'",
        "':left-assoc'",
        "':license'",
        "':named'",
        "':name'",
        "':notes'",
        "':pattern'",
        "':print-success'",
        "':produce-assertions'",
        "':produce-assignments'",
        "':produce-models'",
        "':produce-proofs'",
        "':produce-unsat-assumptions'",
        "':produce-unsat-cores'",
        "':random-seed'",
        "':reason-unknown'",
        "':regular-output-channel'",
        "':reproducible-resource-limit'",
        "':right-assoc'",
        "':smt-lib-version'",
        "':sorts'",
        "':sorts-description'",
        "':source'",
        "':status'",
        "':theories'",
        "':values'",
        "':verbosity'",
        "':version'",
    ]

    symbolicNames = [
        "<INVALID>",
        "<INVALID>",
        "Comment",
        "ParOpen",
        "ParClose",
        "Semicolon",
        "String",
        "QuotedSymbol",
        "RegConst",
        "PS_Not",
        "PS_Bool",
        "PS_Int",
        "PS_Real",
        "PS_ContinuedExecution",
        "PS_Error",
        "PS_False",
        "PS_ImmediateExit",
        "PS_Incomplete",
        "PS_Logic",
        "PS_Memout",
        "PS_Sat",
        "PS_Success",
        "PS_Theory",
        "PS_True",
        "PS_Unknown",
        "PS_Unsupported",
        "PS_Unsat",
        "CMD_Assert",
        "CMD_AssertSoft",
        "Simplify",
        "CMD_CheckSat",
        "CMD_CheckSatAssuming",
        "CMD_CheckSatUsing",
        "CMD_Labels",
        "CMD_Minimize",
        "CMD_Maximize",
        "CMD_DeclareConst",
        "CMD_DeclareDatatype",
        "CMD_DeclareCodatatype",
        "CMD_DeclareDatatypes",
        "CMD_DeclareCodatatypes",
        "CMD_DeclareFun",
        "CMD_DeclareSort",
        "CMD_Define",
        "CMD_DefineFun",
        "CMD_DefineConst",
        "CMD_DefineFunRec",
        "CMD_DefineFunsRec",
        "CMD_DefineSort",
        "CMD_Display",
        "CMD_Echo",
        "CMD_Eval",
        "CMD_Exit",
        "CMD_GetObjectives",
        "CMD_GetAssertions",
        "CMD_GetAssignment",
        "CMD_GetInfo",
        "CMD_GetModel",
        "CMD_BlockModel",
        "CMD_GetOption",
        "CMD_PolyFactor",
        "CMD_GetProof",
        "CMD_GetUnsatAssumptions",
        "CMD_GetUnsatCore",
        "CMD_GetValue",
        "CMD_Pop",
        "CMD_Push",
        "CMD_Reset",
        "CMD_ResetAssertions",
        "CMD_SetInfo",
        "CMD_SetLogic",
        "CMD_SetOption",
        "TAC_Then",
        "TAC_AndThen",
        "TAC_ParThen",
        "TAC_OrElse",
        "TAC_ParOrElse",
        "TAC_ParOr",
        "TAC_TryFor",
        "TAC_UsingParams",
        "GRW_Exclamation",
        "GRW_Underscore",
        "GRW_As",
        "GRW_Binary",
        "GRW_Decimal",
        "GRW_Exists",
        "GRW_Hexadecimal",
        "GRW_Forall",
        "GRW_Let",
        "GRW_Match",
        "GRW_Numeral",
        "GRW_Par",
        "Numeral",
        "Binary",
        "HexDecimal",
        "Decimal",
        "Colon",
        "PK_AllStatistics",
        "PK_AssertionStackLevels",
        "PK_Authors",
        "PK_Category",
        "PK_Chainable",
        "PK_Definition",
        "PK_DiagnosticOutputChannel",
        "PK_ErrorBehaviour",
        "PK_Extension",
        "PK_Funs",
        "PK_FunsDescription",
        "PK_GlobalDeclarations",
        "PK_InteractiveMode",
        "PK_Language",
        "PK_LeftAssoc",
        "PK_License",
        "PK_Named",
        "PK_Name",
        "PK_Notes",
        "PK_Pattern",
        "PK_PrintSuccess",
        "PK_ProduceAssertions",
        "PK_ProduceAssignments",
        "PK_ProduceModels",
        "PK_ProduceProofs",
        "PK_ProduceUnsatAssumptions",
        "PK_ProduceUnsatCores",
        "PK_RandomSeed",
        "PK_ReasonUnknown",
        "PK_RegularOutputChannel",
        "PK_ReproducibleResourceLimit",
        "PK_RightAssoc",
        "PK_SmtLibVersion",
        "PK_Sorts",
        "PK_SortsDescription",
        "PK_Source",
        "PK_Status",
        "PK_Theories",
        "PK_Values",
        "PK_Verbosity",
        "PK_Version",
        "UndefinedSymbol",
        "WS",
    ]

    RULE_start = 0
    RULE_response = 1
    RULE_generalReservedWord = 2
    RULE_simpleSymbol = 3
    RULE_quotedSymbol = 4
    RULE_predefSymbol = 5
    RULE_predefKeyword = 6
    RULE_symbol = 7
    RULE_numeral = 8
    RULE_decimal = 9
    RULE_hexadecimal = 10
    RULE_binary = 11
    RULE_string = 12
    RULE_reg_const = 13
    RULE_keyword = 14
    RULE_spec_constant = 15
    RULE_s_expr = 16
    RULE_index = 17
    RULE_identifier = 18
    RULE_attribute_value = 19
    RULE_attribute = 20
    RULE_sort = 21
    RULE_qual_identifier = 22
    RULE_var_binding = 23
    RULE_sorted_var = 24
    RULE_pattern = 25
    RULE_match_case = 26
    RULE_term = 27
    RULE_sort_symbol_decl = 28
    RULE_meta_spec_constant = 29
    RULE_fun_symbol_decl = 30
    RULE_par_fun_symbol_decl = 31
    RULE_theory_attribute = 32
    RULE_theory_decl = 33
    RULE_logic_attribue = 34
    RULE_logic = 35
    RULE_sort_dec = 36
    RULE_selector_dec = 37
    RULE_constructor_dec = 38
    RULE_datatype_dec = 39
    RULE_function_dec = 40
    RULE_function_def = 41
    RULE_prop_literal = 42
    RULE_script = 43
    RULE_cmd_assert = 44
    RULE_cmd_assertSoft = 45
    RULE_cmd_simplify = 46
    RULE_cmd_checkSat = 47
    RULE_cmd_checkSatAssuming = 48
    RULE_cmd_checkSatUsing = 49
    RULE_cmd_minimize = 50
    RULE_cmd_maximize = 51
    RULE_cmd_declareConst = 52
    RULE_cmd_declareDatatype = 53
    RULE_cmd_declareCodatatype = 54
    RULE_cmd_declareDatatypes = 55
    RULE_cmd_declareCodatatypes = 56
    RULE_cmd_declareFun = 57
    RULE_cmd_declareSort = 58
    RULE_cmd_define = 59
    RULE_cmd_defineFun = 60
    RULE_cmd_defineConst = 61
    RULE_cmd_defineFunRec = 62
    RULE_cmd_defineFunsRec = 63
    RULE_cmd_defineSort = 64
    RULE_cmd_display = 65
    RULE_cmd_echo = 66
    RULE_cmd_eval = 67
    RULE_cmd_exit = 68
    RULE_cmd_GetObjectives = 69
    RULE_cmd_getAssertions = 70
    RULE_cmd_getAssignment = 71
    RULE_cmd_getInfo = 72
    RULE_cmd_getModel = 73
    RULE_cmd_blockModel = 74
    RULE_cmd_getOption = 75
    RULE_cmd_getProof = 76
    RULE_cmd_getUnsatAssumptions = 77
    RULE_cmd_labels = 78
    RULE_cmd_getUnsatCore = 79
    RULE_cmd_getValue = 80
    RULE_cmd_pop = 81
    RULE_cmd_poly_factor = 82
    RULE_cmd_push = 83
    RULE_cmd_reset = 84
    RULE_cmd_resetAssertions = 85
    RULE_cmd_setInfo = 86
    RULE_cmd_setLogic = 87
    RULE_cmd_setOption = 88
    RULE_tac_then = 89
    RULE_tac_and_then = 90
    RULE_par_then = 91
    RULE_or_else = 92
    RULE_par_or_else = 93
    RULE_par_or = 94
    RULE_tryFor = 95
    RULE_usingParams = 96
    RULE_tactical = 97
    RULE_command = 98
    RULE_b_value = 99
    RULE_option = 100
    RULE_info_flag = 101
    RULE_error_behaviour = 102
    RULE_reason_unknown = 103
    RULE_model_response = 104
    RULE_info_response = 105
    RULE_valuation_pair = 106
    RULE_t_valuation_pair = 107
    RULE_check_sat_response = 108
    RULE_echo_response = 109
    RULE_get_assertions_response = 110
    RULE_get_assignment_response = 111
    RULE_get_info_response = 112
    RULE_get_model_response = 113
    RULE_get_option_response = 114
    RULE_get_proof_response = 115
    RULE_get_unsat_assump_response = 116
    RULE_get_unsat_core_response = 117
    RULE_get_value_response = 118
    RULE_specific_success_response = 119
    RULE_general_response = 120

    ruleNames = [
        "start",
        "response",
        "generalReservedWord",
        "simpleSymbol",
        "quotedSymbol",
        "predefSymbol",
        "predefKeyword",
        "symbol",
        "numeral",
        "decimal",
        "hexadecimal",
        "binary",
        "string",
        "reg_const",
        "keyword",
        "spec_constant",
        "s_expr",
        "index",
        "identifier",
        "attribute_value",
        "attribute",
        "sort",
        "qual_identifier",
        "var_binding",
        "sorted_var",
        "pattern",
        "match_case",
        "term",
        "sort_symbol_decl",
        "meta_spec_constant",
        "fun_symbol_decl",
        "par_fun_symbol_decl",
        "theory_attribute",
        "theory_decl",
        "logic_attribue",
        "logic",
        "sort_dec",
        "selector_dec",
        "constructor_dec",
        "datatype_dec",
        "function_dec",
        "function_def",
        "prop_literal",
        "script",
        "cmd_assert",
        "cmd_assertSoft",
        "cmd_simplify",
        "cmd_checkSat",
        "cmd_checkSatAssuming",
        "cmd_checkSatUsing",
        "cmd_minimize",
        "cmd_maximize",
        "cmd_declareConst",
        "cmd_declareDatatype",
        "cmd_declareCodatatype",
        "cmd_declareDatatypes",
        "cmd_declareCodatatypes",
        "cmd_declareFun",
        "cmd_declareSort",
        "cmd_define",
        "cmd_defineFun",
        "cmd_defineConst",
        "cmd_defineFunRec",
        "cmd_defineFunsRec",
        "cmd_defineSort",
        "cmd_display",
        "cmd_echo",
        "cmd_eval",
        "cmd_exit",
        "cmd_GetObjectives",
        "cmd_getAssertions",
        "cmd_getAssignment",
        "cmd_getInfo",
        "cmd_getModel",
        "cmd_blockModel",
        "cmd_getOption",
        "cmd_getProof",
        "cmd_getUnsatAssumptions",
        "cmd_labels",
        "cmd_getUnsatCore",
        "cmd_getValue",
        "cmd_pop",
        "cmd_poly_factor",
        "cmd_push",
        "cmd_reset",
        "cmd_resetAssertions",
        "cmd_setInfo",
        "cmd_setLogic",
        "cmd_setOption",
        "tac_then",
        "tac_and_then",
        "par_then",
        "or_else",
        "par_or_else",
        "par_or",
        "tryFor",
        "usingParams",
        "tactical",
        "command",
        "b_value",
        "option",
        "info_flag",
        "error_behaviour",
        "reason_unknown",
        "model_response",
        "info_response",
        "valuation_pair",
        "t_valuation_pair",
        "check_sat_response",
        "echo_response",
        "get_assertions_response",
        "get_assignment_response",
        "get_info_response",
        "get_model_response",
        "get_option_response",
        "get_proof_response",
        "get_unsat_assump_response",
        "get_unsat_core_response",
        "get_value_response",
        "specific_success_response",
        "general_response",
    ]

    EOF = Token.EOF
    T__0 = 1
    Comment = 2
    ParOpen = 3
    ParClose = 4
    Semicolon = 5
    String = 6
    QuotedSymbol = 7
    RegConst = 8
    PS_Not = 9
    PS_Bool = 10
    PS_Int = 11
    PS_Real = 12
    PS_ContinuedExecution = 13
    PS_Error = 14
    PS_False = 15
    PS_ImmediateExit = 16
    PS_Incomplete = 17
    PS_Logic = 18
    PS_Memout = 19
    PS_Sat = 20
    PS_Success = 21
    PS_Theory = 22
    PS_True = 23
    PS_Unknown = 24
    PS_Unsupported = 25
    PS_Unsat = 26
    CMD_Assert = 27
    CMD_AssertSoft = 28
    Simplify = 29
    CMD_CheckSat = 30
    CMD_CheckSatAssuming = 31
    CMD_CheckSatUsing = 32
    CMD_Labels = 33
    CMD_Minimize = 34
    CMD_Maximize = 35
    CMD_DeclareConst = 36
    CMD_DeclareDatatype = 37
    CMD_DeclareCodatatype = 38
    CMD_DeclareDatatypes = 39
    CMD_DeclareCodatatypes = 40
    CMD_DeclareFun = 41
    CMD_DeclareSort = 42
    CMD_Define = 43
    CMD_DefineFun = 44
    CMD_DefineConst = 45
    CMD_DefineFunRec = 46
    CMD_DefineFunsRec = 47
    CMD_DefineSort = 48
    CMD_Display = 49
    CMD_Echo = 50
    CMD_Eval = 51
    CMD_Exit = 52
    CMD_GetObjectives = 53
    CMD_GetAssertions = 54
    CMD_GetAssignment = 55
    CMD_GetInfo = 56
    CMD_GetModel = 57
    CMD_BlockModel = 58
    CMD_GetOption = 59
    CMD_PolyFactor = 60
    CMD_GetProof = 61
    CMD_GetUnsatAssumptions = 62
    CMD_GetUnsatCore = 63
    CMD_GetValue = 64
    CMD_Pop = 65
    CMD_Push = 66
    CMD_Reset = 67
    CMD_ResetAssertions = 68
    CMD_SetInfo = 69
    CMD_SetLogic = 70
    CMD_SetOption = 71
    TAC_Then = 72
    TAC_AndThen = 73
    TAC_ParThen = 74
    TAC_OrElse = 75
    TAC_ParOrElse = 76
    TAC_ParOr = 77
    TAC_TryFor = 78
    TAC_UsingParams = 79
    GRW_Exclamation = 80
    GRW_Underscore = 81
    GRW_As = 82
    GRW_Binary = 83
    GRW_Decimal = 84
    GRW_Exists = 85
    GRW_Hexadecimal = 86
    GRW_Forall = 87
    GRW_Let = 88
    GRW_Match = 89
    GRW_Numeral = 90
    GRW_Par = 91
    Numeral = 92
    Binary = 93
    HexDecimal = 94
    Decimal = 95
    Colon = 96
    PK_AllStatistics = 97
    PK_AssertionStackLevels = 98
    PK_Authors = 99
    PK_Category = 100
    PK_Chainable = 101
    PK_Definition = 102
    PK_DiagnosticOutputChannel = 103
    PK_ErrorBehaviour = 104
    PK_Extension = 105
    PK_Funs = 106
    PK_FunsDescription = 107
    PK_GlobalDeclarations = 108
    PK_InteractiveMode = 109
    PK_Language = 110
    PK_LeftAssoc = 111
    PK_License = 112
    PK_Named = 113
    PK_Name = 114
    PK_Notes = 115
    PK_Pattern = 116
    PK_PrintSuccess = 117
    PK_ProduceAssertions = 118
    PK_ProduceAssignments = 119
    PK_ProduceModels = 120
    PK_ProduceProofs = 121
    PK_ProduceUnsatAssumptions = 122
    PK_ProduceUnsatCores = 123
    PK_RandomSeed = 124
    PK_ReasonUnknown = 125
    PK_RegularOutputChannel = 126
    PK_ReproducibleResourceLimit = 127
    PK_RightAssoc = 128
    PK_SmtLibVersion = 129
    PK_Sorts = 130
    PK_SortsDescription = 131
    PK_Source = 132
    PK_Status = 133
    PK_Theories = 134
    PK_Values = 135
    PK_Verbosity = 136
    PK_Version = 137
    UndefinedSymbol = 138
    WS = 139

    def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.2")
        self._interp = ParserATNSimulator(
            self, self.atn, self.decisionsToDFA, self.sharedContextCache
        )
        self._predicates = None

    class StartContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def script(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.ScriptContext, 0)

        def EOF(self):
            return self.getToken(SMTLIBv2Parser.EOF, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_start

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStart"):
                listener.enterStart(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStart"):
                listener.exitStart(self)

    def start(self):

        localctx = SMTLIBv2Parser.StartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_start)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 242
            self.script()
            self.state = 243
            self.match(SMTLIBv2Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ResponseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def general_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.General_responseContext, 0)

        def EOF(self):
            return self.getToken(SMTLIBv2Parser.EOF, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterResponse"):
                listener.enterResponse(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitResponse"):
                listener.exitResponse(self)

    def response(self):

        localctx = SMTLIBv2Parser.ResponseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_response)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            self.general_response()
            self.state = 246
            self.match(SMTLIBv2Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GeneralReservedWordContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GRW_Exclamation(self):
            return self.getToken(SMTLIBv2Parser.GRW_Exclamation, 0)

        def GRW_Underscore(self):
            return self.getToken(SMTLIBv2Parser.GRW_Underscore, 0)

        def GRW_As(self):
            return self.getToken(SMTLIBv2Parser.GRW_As, 0)

        def GRW_Binary(self):
            return self.getToken(SMTLIBv2Parser.GRW_Binary, 0)

        def GRW_Decimal(self):
            return self.getToken(SMTLIBv2Parser.GRW_Decimal, 0)

        def GRW_Exists(self):
            return self.getToken(SMTLIBv2Parser.GRW_Exists, 0)

        def GRW_Hexadecimal(self):
            return self.getToken(SMTLIBv2Parser.GRW_Hexadecimal, 0)

        def GRW_Forall(self):
            return self.getToken(SMTLIBv2Parser.GRW_Forall, 0)

        def GRW_Let(self):
            return self.getToken(SMTLIBv2Parser.GRW_Let, 0)

        def GRW_Match(self):
            return self.getToken(SMTLIBv2Parser.GRW_Match, 0)

        def GRW_Numeral(self):
            return self.getToken(SMTLIBv2Parser.GRW_Numeral, 0)

        def GRW_Par(self):
            return self.getToken(SMTLIBv2Parser.GRW_Par, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_generalReservedWord

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGeneralReservedWord"):
                listener.enterGeneralReservedWord(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGeneralReservedWord"):
                listener.exitGeneralReservedWord(self)

    def generalReservedWord(self):

        localctx = SMTLIBv2Parser.GeneralReservedWordContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 4, self.RULE_generalReservedWord)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            _la = self._input.LA(1)
            if not (
                (
                    (((_la - 80)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 80))
                        & (
                            (1 << (SMTLIBv2Parser.GRW_Exclamation - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Underscore - 80))
                            | (1 << (SMTLIBv2Parser.GRW_As - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Binary - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Decimal - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Exists - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Hexadecimal - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Forall - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Let - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Match - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Numeral - 80))
                            | (1 << (SMTLIBv2Parser.GRW_Par - 80))
                        )
                    )
                    != 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 SimpleSymbolContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def predefSymbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.PredefSymbolContext, 0)

        def UndefinedSymbol(self):
            return self.getToken(SMTLIBv2Parser.UndefinedSymbol, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_simpleSymbol

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSimpleSymbol"):
                listener.enterSimpleSymbol(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSimpleSymbol"):
                listener.exitSimpleSymbol(self)

    def simpleSymbol(self):

        localctx = SMTLIBv2Parser.SimpleSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_simpleSymbol)
        try:
            self.state = 252
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 250
                self.predefSymbol()
                pass
            elif token in [SMTLIBv2Parser.UndefinedSymbol]:
                self.enterOuterAlt(localctx, 2)
                self.state = 251
                self.match(SMTLIBv2Parser.UndefinedSymbol)
                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 QuotedSymbolContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def QuotedSymbol(self):
            return self.getToken(SMTLIBv2Parser.QuotedSymbol, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_quotedSymbol

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterQuotedSymbol"):
                listener.enterQuotedSymbol(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitQuotedSymbol"):
                listener.exitQuotedSymbol(self)

    def quotedSymbol(self):

        localctx = SMTLIBv2Parser.QuotedSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_quotedSymbol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.match(SMTLIBv2Parser.QuotedSymbol)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PredefSymbolContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_Not(self):
            return self.getToken(SMTLIBv2Parser.PS_Not, 0)

        def PS_Bool(self):
            return self.getToken(SMTLIBv2Parser.PS_Bool, 0)

        def PS_Int(self):
            return self.getToken(SMTLIBv2Parser.PS_Int, 0)

        def PS_Real(self):
            return self.getToken(SMTLIBv2Parser.PS_Real, 0)

        def PS_ContinuedExecution(self):
            return self.getToken(SMTLIBv2Parser.PS_ContinuedExecution, 0)

        def PS_Error(self):
            return self.getToken(SMTLIBv2Parser.PS_Error, 0)

        def PS_False(self):
            return self.getToken(SMTLIBv2Parser.PS_False, 0)

        def PS_ImmediateExit(self):
            return self.getToken(SMTLIBv2Parser.PS_ImmediateExit, 0)

        def PS_Incomplete(self):
            return self.getToken(SMTLIBv2Parser.PS_Incomplete, 0)

        def PS_Logic(self):
            return self.getToken(SMTLIBv2Parser.PS_Logic, 0)

        def PS_Memout(self):
            return self.getToken(SMTLIBv2Parser.PS_Memout, 0)

        def PS_Sat(self):
            return self.getToken(SMTLIBv2Parser.PS_Sat, 0)

        def PS_Success(self):
            return self.getToken(SMTLIBv2Parser.PS_Success, 0)

        def PS_Theory(self):
            return self.getToken(SMTLIBv2Parser.PS_Theory, 0)

        def PS_True(self):
            return self.getToken(SMTLIBv2Parser.PS_True, 0)

        def PS_Unknown(self):
            return self.getToken(SMTLIBv2Parser.PS_Unknown, 0)

        def PS_Unsupported(self):
            return self.getToken(SMTLIBv2Parser.PS_Unsupported, 0)

        def PS_Unsat(self):
            return self.getToken(SMTLIBv2Parser.PS_Unsat, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_predefSymbol

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPredefSymbol"):
                listener.enterPredefSymbol(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPredefSymbol"):
                listener.exitPredefSymbol(self)

    def predefSymbol(self):

        localctx = SMTLIBv2Parser.PredefSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_predefSymbol)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 256
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 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 PredefKeywordContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_AllStatistics(self):
            return self.getToken(SMTLIBv2Parser.PK_AllStatistics, 0)

        def PK_AssertionStackLevels(self):
            return self.getToken(SMTLIBv2Parser.PK_AssertionStackLevels, 0)

        def PK_Authors(self):
            return self.getToken(SMTLIBv2Parser.PK_Authors, 0)

        def PK_Category(self):
            return self.getToken(SMTLIBv2Parser.PK_Category, 0)

        def PK_Chainable(self):
            return self.getToken(SMTLIBv2Parser.PK_Chainable, 0)

        def PK_Definition(self):
            return self.getToken(SMTLIBv2Parser.PK_Definition, 0)

        def PK_DiagnosticOutputChannel(self):
            return self.getToken(SMTLIBv2Parser.PK_DiagnosticOutputChannel, 0)

        def PK_ErrorBehaviour(self):
            return self.getToken(SMTLIBv2Parser.PK_ErrorBehaviour, 0)

        def PK_Extension(self):
            return self.getToken(SMTLIBv2Parser.PK_Extension, 0)

        def PK_Funs(self):
            return self.getToken(SMTLIBv2Parser.PK_Funs, 0)

        def PK_FunsDescription(self):
            return self.getToken(SMTLIBv2Parser.PK_FunsDescription, 0)

        def PK_GlobalDeclarations(self):
            return self.getToken(SMTLIBv2Parser.PK_GlobalDeclarations, 0)

        def PK_InteractiveMode(self):
            return self.getToken(SMTLIBv2Parser.PK_InteractiveMode, 0)

        def PK_Language(self):
            return self.getToken(SMTLIBv2Parser.PK_Language, 0)

        def PK_LeftAssoc(self):
            return self.getToken(SMTLIBv2Parser.PK_LeftAssoc, 0)

        def PK_License(self):
            return self.getToken(SMTLIBv2Parser.PK_License, 0)

        def PK_Named(self):
            return self.getToken(SMTLIBv2Parser.PK_Named, 0)

        def PK_Name(self):
            return self.getToken(SMTLIBv2Parser.PK_Name, 0)

        def PK_Notes(self):
            return self.getToken(SMTLIBv2Parser.PK_Notes, 0)

        def PK_Pattern(self):
            return self.getToken(SMTLIBv2Parser.PK_Pattern, 0)

        def PK_PrintSuccess(self):
            return self.getToken(SMTLIBv2Parser.PK_PrintSuccess, 0)

        def PK_ProduceAssertions(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceAssertions, 0)

        def PK_ProduceAssignments(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceAssignments, 0)

        def PK_ProduceModels(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceModels, 0)

        def PK_ProduceProofs(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceProofs, 0)

        def PK_ProduceUnsatAssumptions(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceUnsatAssumptions, 0)

        def PK_ProduceUnsatCores(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceUnsatCores, 0)

        def PK_RandomSeed(self):
            return self.getToken(SMTLIBv2Parser.PK_RandomSeed, 0)

        def PK_ReasonUnknown(self):
            return self.getToken(SMTLIBv2Parser.PK_ReasonUnknown, 0)

        def PK_RegularOutputChannel(self):
            return self.getToken(SMTLIBv2Parser.PK_RegularOutputChannel, 0)

        def PK_ReproducibleResourceLimit(self):
            return self.getToken(SMTLIBv2Parser.PK_ReproducibleResourceLimit, 0)

        def PK_RightAssoc(self):
            return self.getToken(SMTLIBv2Parser.PK_RightAssoc, 0)

        def PK_SmtLibVersion(self):
            return self.getToken(SMTLIBv2Parser.PK_SmtLibVersion, 0)

        def PK_Sorts(self):
            return self.getToken(SMTLIBv2Parser.PK_Sorts, 0)

        def PK_SortsDescription(self):
            return self.getToken(SMTLIBv2Parser.PK_SortsDescription, 0)

        def PK_Source(self):
            return self.getToken(SMTLIBv2Parser.PK_Source, 0)

        def PK_Status(self):
            return self.getToken(SMTLIBv2Parser.PK_Status, 0)

        def PK_Theories(self):
            return self.getToken(SMTLIBv2Parser.PK_Theories, 0)

        def PK_Values(self):
            return self.getToken(SMTLIBv2Parser.PK_Values, 0)

        def PK_Verbosity(self):
            return self.getToken(SMTLIBv2Parser.PK_Verbosity, 0)

        def PK_Version(self):
            return self.getToken(SMTLIBv2Parser.PK_Version, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_predefKeyword

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPredefKeyword"):
                listener.enterPredefKeyword(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPredefKeyword"):
                listener.exitPredefKeyword(self)

    def predefKeyword(self):

        localctx = SMTLIBv2Parser.PredefKeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_predefKeyword)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            _la = self._input.LA(1)
            if not (
                (
                    (((_la - 97)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 97))
                        & (
                            (1 << (SMTLIBv2Parser.PK_AllStatistics - 97))
                            | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 97))
                            | (1 << (SMTLIBv2Parser.PK_Authors - 97))
                            | (1 << (SMTLIBv2Parser.PK_Category - 97))
                            | (1 << (SMTLIBv2Parser.PK_Chainable - 97))
                            | (1 << (SMTLIBv2Parser.PK_Definition - 97))
                            | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 97))
                            | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 97))
                            | (1 << (SMTLIBv2Parser.PK_Extension - 97))
                            | (1 << (SMTLIBv2Parser.PK_Funs - 97))
                            | (1 << (SMTLIBv2Parser.PK_FunsDescription - 97))
                            | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 97))
                            | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 97))
                            | (1 << (SMTLIBv2Parser.PK_Language - 97))
                            | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 97))
                            | (1 << (SMTLIBv2Parser.PK_License - 97))
                            | (1 << (SMTLIBv2Parser.PK_Named - 97))
                            | (1 << (SMTLIBv2Parser.PK_Name - 97))
                            | (1 << (SMTLIBv2Parser.PK_Notes - 97))
                            | (1 << (SMTLIBv2Parser.PK_Pattern - 97))
                            | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceModels - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 97))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 97))
                            | (1 << (SMTLIBv2Parser.PK_RandomSeed - 97))
                            | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 97))
                            | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 97))
                            | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 97))
                            | (1 << (SMTLIBv2Parser.PK_RightAssoc - 97))
                            | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 97))
                            | (1 << (SMTLIBv2Parser.PK_Sorts - 97))
                            | (1 << (SMTLIBv2Parser.PK_SortsDescription - 97))
                            | (1 << (SMTLIBv2Parser.PK_Source - 97))
                            | (1 << (SMTLIBv2Parser.PK_Status - 97))
                            | (1 << (SMTLIBv2Parser.PK_Theories - 97))
                            | (1 << (SMTLIBv2Parser.PK_Values - 97))
                            | (1 << (SMTLIBv2Parser.PK_Verbosity - 97))
                            | (1 << (SMTLIBv2Parser.PK_Version - 97))
                        )
                    )
                    != 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 SymbolContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleSymbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SimpleSymbolContext, 0)

        def quotedSymbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.QuotedSymbolContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_symbol

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSymbol"):
                listener.enterSymbol(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSymbol"):
                listener.exitSymbol(self)

    def symbol(self):

        localctx = SMTLIBv2Parser.SymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_symbol)
        try:
            self.state = 262
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
                SMTLIBv2Parser.UndefinedSymbol,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 260
                self.simpleSymbol()
                pass
            elif token in [SMTLIBv2Parser.QuotedSymbol]:
                self.enterOuterAlt(localctx, 2)
                self.state = 261
                self.quotedSymbol()
                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 NumeralContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Numeral(self):
            return self.getToken(SMTLIBv2Parser.Numeral, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_numeral

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterNumeral"):
                listener.enterNumeral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitNumeral"):
                listener.exitNumeral(self)

    def numeral(self):

        localctx = SMTLIBv2Parser.NumeralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_numeral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 264
            self.match(SMTLIBv2Parser.Numeral)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DecimalContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Decimal(self):
            return self.getToken(SMTLIBv2Parser.Decimal, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_decimal

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDecimal"):
                listener.enterDecimal(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDecimal"):
                listener.exitDecimal(self)

    def decimal(self):

        localctx = SMTLIBv2Parser.DecimalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_decimal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 266
            self.match(SMTLIBv2Parser.Decimal)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class HexadecimalContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def HexDecimal(self):
            return self.getToken(SMTLIBv2Parser.HexDecimal, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_hexadecimal

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterHexadecimal"):
                listener.enterHexadecimal(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitHexadecimal"):
                listener.exitHexadecimal(self)

    def hexadecimal(self):

        localctx = SMTLIBv2Parser.HexadecimalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_hexadecimal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self.match(SMTLIBv2Parser.HexDecimal)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BinaryContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Binary(self):
            return self.getToken(SMTLIBv2Parser.Binary, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_binary

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBinary"):
                listener.enterBinary(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBinary"):
                listener.exitBinary(self)

    def binary(self):

        localctx = SMTLIBv2Parser.BinaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_binary)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.match(SMTLIBv2Parser.Binary)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StringContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def String(self):
            return self.getToken(SMTLIBv2Parser.String, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_string

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterString"):
                listener.enterString(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitString"):
                listener.exitString(self)

    def string(self):

        localctx = SMTLIBv2Parser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_string)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 272
            self.match(SMTLIBv2Parser.String)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Reg_constContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RegConst(self):
            return self.getToken(SMTLIBv2Parser.RegConst, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_reg_const

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterReg_const"):
                listener.enterReg_const(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitReg_const"):
                listener.exitReg_const(self)

    def reg_const(self):

        localctx = SMTLIBv2Parser.Reg_constContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_reg_const)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 274
            self.match(SMTLIBv2Parser.RegConst)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class KeywordContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def predefKeyword(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.PredefKeywordContext, 0)

        def Colon(self):
            return self.getToken(SMTLIBv2Parser.Colon, 0)

        def simpleSymbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SimpleSymbolContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_keyword

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterKeyword"):
                listener.enterKeyword(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitKeyword"):
                listener.exitKeyword(self)

    def keyword(self):

        localctx = SMTLIBv2Parser.KeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_keyword)
        try:
            self.state = 279
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.PK_AllStatistics,
                SMTLIBv2Parser.PK_AssertionStackLevels,
                SMTLIBv2Parser.PK_Authors,
                SMTLIBv2Parser.PK_Category,
                SMTLIBv2Parser.PK_Chainable,
                SMTLIBv2Parser.PK_Definition,
                SMTLIBv2Parser.PK_DiagnosticOutputChannel,
                SMTLIBv2Parser.PK_ErrorBehaviour,
                SMTLIBv2Parser.PK_Extension,
                SMTLIBv2Parser.PK_Funs,
                SMTLIBv2Parser.PK_FunsDescription,
                SMTLIBv2Parser.PK_GlobalDeclarations,
                SMTLIBv2Parser.PK_InteractiveMode,
                SMTLIBv2Parser.PK_Language,
                SMTLIBv2Parser.PK_LeftAssoc,
                SMTLIBv2Parser.PK_License,
                SMTLIBv2Parser.PK_Named,
                SMTLIBv2Parser.PK_Name,
                SMTLIBv2Parser.PK_Notes,
                SMTLIBv2Parser.PK_Pattern,
                SMTLIBv2Parser.PK_PrintSuccess,
                SMTLIBv2Parser.PK_ProduceAssertions,
                SMTLIBv2Parser.PK_ProduceAssignments,
                SMTLIBv2Parser.PK_ProduceModels,
                SMTLIBv2Parser.PK_ProduceProofs,
                SMTLIBv2Parser.PK_ProduceUnsatAssumptions,
                SMTLIBv2Parser.PK_ProduceUnsatCores,
                SMTLIBv2Parser.PK_RandomSeed,
                SMTLIBv2Parser.PK_ReasonUnknown,
                SMTLIBv2Parser.PK_RegularOutputChannel,
                SMTLIBv2Parser.PK_ReproducibleResourceLimit,
                SMTLIBv2Parser.PK_RightAssoc,
                SMTLIBv2Parser.PK_SmtLibVersion,
                SMTLIBv2Parser.PK_Sorts,
                SMTLIBv2Parser.PK_SortsDescription,
                SMTLIBv2Parser.PK_Source,
                SMTLIBv2Parser.PK_Status,
                SMTLIBv2Parser.PK_Theories,
                SMTLIBv2Parser.PK_Values,
                SMTLIBv2Parser.PK_Verbosity,
                SMTLIBv2Parser.PK_Version,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 276
                self.predefKeyword()
                pass
            elif token in [SMTLIBv2Parser.Colon]:
                self.enterOuterAlt(localctx, 2)
                self.state = 277
                self.match(SMTLIBv2Parser.Colon)
                self.state = 278
                self.simpleSymbol()
                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 Spec_constantContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def numeral(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.NumeralContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, i)

        def decimal(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.DecimalContext, 0)

        def hexadecimal(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.HexadecimalContext, 0)

        def binary(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.BinaryContext, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def b_value(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.B_valueContext, 0)

        def reg_const(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Reg_constContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def GRW_Underscore(self):
            return self.getToken(SMTLIBv2Parser.GRW_Underscore, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_spec_constant

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSpec_constant"):
                listener.enterSpec_constant(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSpec_constant"):
                listener.exitSpec_constant(self)

    def spec_constant(self):

        localctx = SMTLIBv2Parser.Spec_constantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_spec_constant)
        try:
            self.state = 295
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SMTLIBv2Parser.Numeral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 281
                self.numeral()
                pass
            elif token in [SMTLIBv2Parser.Decimal]:
                self.enterOuterAlt(localctx, 2)
                self.state = 282
                self.decimal()
                pass
            elif token in [SMTLIBv2Parser.HexDecimal]:
                self.enterOuterAlt(localctx, 3)
                self.state = 283
                self.hexadecimal()
                pass
            elif token in [SMTLIBv2Parser.Binary]:
                self.enterOuterAlt(localctx, 4)
                self.state = 284
                self.binary()
                pass
            elif token in [SMTLIBv2Parser.String]:
                self.enterOuterAlt(localctx, 5)
                self.state = 285
                self.string()
                pass
            elif token in [SMTLIBv2Parser.PS_False, SMTLIBv2Parser.PS_True]:
                self.enterOuterAlt(localctx, 6)
                self.state = 286
                self.b_value()
                pass
            elif token in [SMTLIBv2Parser.RegConst]:
                self.enterOuterAlt(localctx, 7)
                self.state = 287
                self.reg_const()
                pass
            elif token in [SMTLIBv2Parser.ParOpen]:
                self.enterOuterAlt(localctx, 8)
                self.state = 288
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 289
                self.match(SMTLIBv2Parser.GRW_Underscore)
                self.state = 290
                self.match(SMTLIBv2Parser.T__0)
                self.state = 291
                self.numeral()
                self.state = 292
                self.numeral()
                self.state = 293
                self.match(SMTLIBv2Parser.ParClose)
                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 S_exprContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def spec_constant(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Spec_constantContext, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def keyword(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.KeywordContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def s_expr(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.S_exprContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.S_exprContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_s_expr

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterS_expr"):
                listener.enterS_expr(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitS_expr"):
                listener.exitS_expr(self)

    def s_expr(self):

        localctx = SMTLIBv2Parser.S_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_s_expr)
        self._la = 0  # Token type
        try:
            self.state = 308
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 5, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 297
                self.spec_constant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 298
                self.symbol()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 299
                self.keyword()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 300
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 304
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.ParOpen)
                            | (1 << SMTLIBv2Parser.String)
                            | (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.RegConst)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 92)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 92))
                        & (
                            (1 << (SMTLIBv2Parser.Numeral - 92))
                            | (1 << (SMTLIBv2Parser.Binary - 92))
                            | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                            | (1 << (SMTLIBv2Parser.Decimal - 92))
                            | (1 << (SMTLIBv2Parser.Colon - 92))
                            | (1 << (SMTLIBv2Parser.PK_AllStatistics - 92))
                            | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 92))
                            | (1 << (SMTLIBv2Parser.PK_Authors - 92))
                            | (1 << (SMTLIBv2Parser.PK_Category - 92))
                            | (1 << (SMTLIBv2Parser.PK_Chainable - 92))
                            | (1 << (SMTLIBv2Parser.PK_Definition - 92))
                            | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 92))
                            | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 92))
                            | (1 << (SMTLIBv2Parser.PK_Extension - 92))
                            | (1 << (SMTLIBv2Parser.PK_Funs - 92))
                            | (1 << (SMTLIBv2Parser.PK_FunsDescription - 92))
                            | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 92))
                            | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 92))
                            | (1 << (SMTLIBv2Parser.PK_Language - 92))
                            | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 92))
                            | (1 << (SMTLIBv2Parser.PK_License - 92))
                            | (1 << (SMTLIBv2Parser.PK_Named - 92))
                            | (1 << (SMTLIBv2Parser.PK_Name - 92))
                            | (1 << (SMTLIBv2Parser.PK_Notes - 92))
                            | (1 << (SMTLIBv2Parser.PK_Pattern - 92))
                            | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceModels - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 92))
                            | (1 << (SMTLIBv2Parser.PK_RandomSeed - 92))
                            | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 92))
                            | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 92))
                            | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 92))
                            | (1 << (SMTLIBv2Parser.PK_RightAssoc - 92))
                            | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 92))
                            | (1 << (SMTLIBv2Parser.PK_Sorts - 92))
                            | (1 << (SMTLIBv2Parser.PK_SortsDescription - 92))
                            | (1 << (SMTLIBv2Parser.PK_Source - 92))
                            | (1 << (SMTLIBv2Parser.PK_Status - 92))
                            | (1 << (SMTLIBv2Parser.PK_Theories - 92))
                            | (1 << (SMTLIBv2Parser.PK_Values - 92))
                            | (1 << (SMTLIBv2Parser.PK_Verbosity - 92))
                            | (1 << (SMTLIBv2Parser.PK_Version - 92))
                            | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                        )
                    )
                    != 0
                ):
                    self.state = 301
                    self.s_expr()
                    self.state = 306
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 307
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IndexContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_index

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterIndex"):
                listener.enterIndex(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitIndex"):
                listener.exitIndex(self)

    def index(self):

        localctx = SMTLIBv2Parser.IndexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_index)
        try:
            self.state = 312
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SMTLIBv2Parser.Numeral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 310
                self.numeral()
                pass
            elif token in [
                SMTLIBv2Parser.QuotedSymbol,
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
                SMTLIBv2Parser.UndefinedSymbol,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 311
                self.symbol()
                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 IdentifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def GRW_Underscore(self):
            return self.getToken(SMTLIBv2Parser.GRW_Underscore, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def index(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.IndexContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.IndexContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_identifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterIdentifier"):
                listener.enterIdentifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitIdentifier"):
                listener.exitIdentifier(self)

    def identifier(self):

        localctx = SMTLIBv2Parser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_identifier)
        self._la = 0  # Token type
        try:
            self.state = 325
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.QuotedSymbol,
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
                SMTLIBv2Parser.UndefinedSymbol,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 314
                self.symbol()
                pass
            elif token in [SMTLIBv2Parser.ParOpen]:
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 316
                self.match(SMTLIBv2Parser.GRW_Underscore)
                self.state = 317
                self.symbol()
                self.state = 319
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 318
                    self.index()
                    self.state = 321
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.Numeral
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 323
                self.match(SMTLIBv2Parser.ParClose)
                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 Attribute_valueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def spec_constant(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Spec_constantContext, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def s_expr(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.S_exprContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.S_exprContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_attribute_value

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAttribute_value"):
                listener.enterAttribute_value(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAttribute_value"):
                listener.exitAttribute_value(self)

    def attribute_value(self):

        localctx = SMTLIBv2Parser.Attribute_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_attribute_value)
        self._la = 0  # Token type
        try:
            self.state = 337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 10, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 327
                self.spec_constant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 328
                self.symbol()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 329
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.ParOpen)
                            | (1 << SMTLIBv2Parser.String)
                            | (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.RegConst)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 92)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 92))
                        & (
                            (1 << (SMTLIBv2Parser.Numeral - 92))
                            | (1 << (SMTLIBv2Parser.Binary - 92))
                            | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                            | (1 << (SMTLIBv2Parser.Decimal - 92))
                            | (1 << (SMTLIBv2Parser.Colon - 92))
                            | (1 << (SMTLIBv2Parser.PK_AllStatistics - 92))
                            | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 92))
                            | (1 << (SMTLIBv2Parser.PK_Authors - 92))
                            | (1 << (SMTLIBv2Parser.PK_Category - 92))
                            | (1 << (SMTLIBv2Parser.PK_Chainable - 92))
                            | (1 << (SMTLIBv2Parser.PK_Definition - 92))
                            | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 92))
                            | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 92))
                            | (1 << (SMTLIBv2Parser.PK_Extension - 92))
                            | (1 << (SMTLIBv2Parser.PK_Funs - 92))
                            | (1 << (SMTLIBv2Parser.PK_FunsDescription - 92))
                            | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 92))
                            | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 92))
                            | (1 << (SMTLIBv2Parser.PK_Language - 92))
                            | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 92))
                            | (1 << (SMTLIBv2Parser.PK_License - 92))
                            | (1 << (SMTLIBv2Parser.PK_Named - 92))
                            | (1 << (SMTLIBv2Parser.PK_Name - 92))
                            | (1 << (SMTLIBv2Parser.PK_Notes - 92))
                            | (1 << (SMTLIBv2Parser.PK_Pattern - 92))
                            | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceModels - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 92))
                            | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 92))
                            | (1 << (SMTLIBv2Parser.PK_RandomSeed - 92))
                            | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 92))
                            | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 92))
                            | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 92))
                            | (1 << (SMTLIBv2Parser.PK_RightAssoc - 92))
                            | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 92))
                            | (1 << (SMTLIBv2Parser.PK_Sorts - 92))
                            | (1 << (SMTLIBv2Parser.PK_SortsDescription - 92))
                            | (1 << (SMTLIBv2Parser.PK_Source - 92))
                            | (1 << (SMTLIBv2Parser.PK_Status - 92))
                            | (1 << (SMTLIBv2Parser.PK_Theories - 92))
                            | (1 << (SMTLIBv2Parser.PK_Values - 92))
                            | (1 << (SMTLIBv2Parser.PK_Verbosity - 92))
                            | (1 << (SMTLIBv2Parser.PK_Version - 92))
                            | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                        )
                    )
                    != 0
                ):
                    self.state = 330
                    self.s_expr()
                    self.state = 335
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 336
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AttributeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keyword(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.KeywordContext, 0)

        def attribute_value(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Attribute_valueContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_attribute

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAttribute"):
                listener.enterAttribute(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAttribute"):
                listener.exitAttribute(self)

    def attribute(self):

        localctx = SMTLIBv2Parser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_attribute)
        try:
            self.state = 343
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 11, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 339
                self.keyword()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 340
                self.keyword()
                self.state = 341
                self.attribute_value()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SortContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def sort(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SortContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_sort

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSort"):
                listener.enterSort(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSort"):
                listener.exitSort(self)

    def sort(self):

        localctx = SMTLIBv2Parser.SortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_sort)
        self._la = 0  # Token type
        try:
            self.state = 355
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 13, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 345
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 346
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 347
                self.identifier()
                self.state = 349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 348
                    self.sort()
                    self.state = 351
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 353
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Qual_identifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def GRW_As(self):
            return self.getToken(SMTLIBv2Parser.GRW_As, 0)

        def sort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_qual_identifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterQual_identifier"):
                listener.enterQual_identifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitQual_identifier"):
                listener.exitQual_identifier(self)

    def qual_identifier(self):

        localctx = SMTLIBv2Parser.Qual_identifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_qual_identifier)
        try:
            self.state = 364
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 14, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 357
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 358
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 359
                self.match(SMTLIBv2Parser.GRW_As)
                self.state = 360
                self.identifier()
                self.state = 361
                self.sort()
                self.state = 362
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Var_bindingContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def term(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_var_binding

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVar_binding"):
                listener.enterVar_binding(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVar_binding"):
                listener.exitVar_binding(self)

    def var_binding(self):

        localctx = SMTLIBv2Parser.Var_bindingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_var_binding)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 367
            self.symbol()
            self.state = 368
            self.term()
            self.state = 369
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Sorted_varContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def sort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_sorted_var

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSorted_var"):
                listener.enterSorted_var(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSorted_var"):
                listener.exitSorted_var(self)

    def sorted_var(self):

        localctx = SMTLIBv2Parser.Sorted_varContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_sorted_var)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 372
            self.symbol()
            self.state = 373
            self.sort()
            self.state = 374
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PatternContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_pattern

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPattern"):
                listener.enterPattern(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPattern"):
                listener.exitPattern(self)

    def pattern(self):

        localctx = SMTLIBv2Parser.PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_pattern)
        self._la = 0  # Token type
        try:
            self.state = 386
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.QuotedSymbol,
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
                SMTLIBv2Parser.UndefinedSymbol,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 376
                self.symbol()
                pass
            elif token in [SMTLIBv2Parser.ParOpen]:
                self.enterOuterAlt(localctx, 2)
                self.state = 377
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 378
                self.symbol()
                self.state = 380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 379
                    self.symbol()
                    self.state = 382
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 384
                self.match(SMTLIBv2Parser.ParClose)
                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 Match_caseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def pattern(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.PatternContext, 0)

        def term(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_match_case

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMatch_case"):
                listener.enterMatch_case(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMatch_case"):
                listener.exitMatch_case(self)

    def match_case(self):

        localctx = SMTLIBv2Parser.Match_caseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_match_case)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 389
            self.pattern()
            self.state = 390
            self.term()
            self.state = 391
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TermContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def spec_constant(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Spec_constantContext, 0)

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def GRW_Underscore(self):
            return self.getToken(SMTLIBv2Parser.GRW_Underscore, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def qual_identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Qual_identifierContext, 0)

        def term(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TermContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, i)

        def GRW_Let(self):
            return self.getToken(SMTLIBv2Parser.GRW_Let, 0)

        def var_binding(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Var_bindingContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Var_bindingContext, i)

        def GRW_Forall(self):
            return self.getToken(SMTLIBv2Parser.GRW_Forall, 0)

        def sorted_var(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Sorted_varContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Sorted_varContext, i)

        def GRW_Exists(self):
            return self.getToken(SMTLIBv2Parser.GRW_Exists, 0)

        def GRW_Match(self):
            return self.getToken(SMTLIBv2Parser.GRW_Match, 0)

        def match_case(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Match_caseContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Match_caseContext, i)

        def GRW_Exclamation(self):
            return self.getToken(SMTLIBv2Parser.GRW_Exclamation, 0)

        def attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_term

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTerm"):
                listener.enterTerm(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTerm"):
                listener.exitTerm(self)

    def term(self):

        localctx = SMTLIBv2Parser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_term)
        self._la = 0  # Token type
        try:
            self.state = 480
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 24, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 393
                self.spec_constant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 394
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 395
                self.match(SMTLIBv2Parser.GRW_Underscore)
                self.state = 396
                self.symbol()
                self.state = 397
                self.numeral()
                self.state = 398
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 400
                self.qual_identifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 401
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 402
                self.qual_identifier()
                self.state = 404
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 403
                    self.term()
                    self.state = 406
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.RegConst)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or (
                            (((_la - 92)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 92))
                                & (
                                    (1 << (SMTLIBv2Parser.Numeral - 92))
                                    | (1 << (SMTLIBv2Parser.Binary - 92))
                                    | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                                    | (1 << (SMTLIBv2Parser.Decimal - 92))
                                    | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 408
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 410
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 411
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 412
                self.match(SMTLIBv2Parser.GRW_Underscore)
                self.state = 413
                self.qual_identifier()
                self.state = 415
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 414
                    self.term()
                    self.state = 417
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.RegConst)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or (
                            (((_la - 92)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 92))
                                & (
                                    (1 << (SMTLIBv2Parser.Numeral - 92))
                                    | (1 << (SMTLIBv2Parser.Binary - 92))
                                    | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                                    | (1 << (SMTLIBv2Parser.Decimal - 92))
                                    | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 419
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 420
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 422
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 423
                self.match(SMTLIBv2Parser.GRW_Let)
                self.state = 424
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 426
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 425
                    self.var_binding()
                    self.state = 428
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 430
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 431
                self.term()
                self.state = 432
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 434
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 435
                self.match(SMTLIBv2Parser.GRW_Forall)
                self.state = 436
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 438
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 437
                    self.sorted_var()
                    self.state = 440
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 442
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 443
                self.term()
                self.state = 444
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 446
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 447
                self.match(SMTLIBv2Parser.GRW_Exists)
                self.state = 448
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 450
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 449
                    self.sorted_var()
                    self.state = 452
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 454
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 455
                self.term()
                self.state = 456
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 458
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 459
                self.match(SMTLIBv2Parser.GRW_Match)
                self.state = 460
                self.term()
                self.state = 461
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 463
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 462
                    self.match_case()
                    self.state = 465
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 467
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 468
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 470
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 471
                self.match(SMTLIBv2Parser.GRW_Exclamation)
                self.state = 472
                self.term()
                self.state = 474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 473
                    self.attribute()
                    self.state = 476
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            (((_la - 96)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 96))
                                & (
                                    (1 << (SMTLIBv2Parser.Colon - 96))
                                    | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                                    | (
                                        1
                                        << (SMTLIBv2Parser.PK_AssertionStackLevels - 96)
                                    )
                                    | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Category - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                                    | (
                                        1
                                        << (
                                            SMTLIBv2Parser.PK_DiagnosticOutputChannel
                                            - 96
                                        )
                                    )
                                    | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                                    | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                                    | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                                    | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Language - 96))
                                    | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                                    | (1 << (SMTLIBv2Parser.PK_License - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Named - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Name - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                                    | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                                    | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                                    | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                                    | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                                    | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                                    | (
                                        1
                                        << (
                                            SMTLIBv2Parser.PK_ProduceUnsatAssumptions
                                            - 96
                                        )
                                    )
                                    | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                                    | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                                    | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                                    | (
                                        1
                                        << (SMTLIBv2Parser.PK_RegularOutputChannel - 96)
                                    )
                                    | (
                                        1
                                        << (
                                            SMTLIBv2Parser.PK_ReproducibleResourceLimit
                                            - 96
                                        )
                                    )
                                    | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                                    | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                                    | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Source - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Status - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Values - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                                    | (1 << (SMTLIBv2Parser.PK_Version - 96))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 478
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Sort_symbol_declContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_sort_symbol_decl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSort_symbol_decl"):
                listener.enterSort_symbol_decl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSort_symbol_decl"):
                listener.exitSort_symbol_decl(self)

    def sort_symbol_decl(self):

        localctx = SMTLIBv2Parser.Sort_symbol_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_sort_symbol_decl)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 482
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 483
            self.identifier()
            self.state = 484
            self.numeral()
            self.state = 488
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la - 96)) & ~0x3F) == 0 and (
                (1 << (_la - 96))
                & (
                    (1 << (SMTLIBv2Parser.Colon - 96))
                    | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                    | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                    | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                    | (1 << (SMTLIBv2Parser.PK_Category - 96))
                    | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                    | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                    | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                    | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                    | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                    | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                    | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                    | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                    | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                    | (1 << (SMTLIBv2Parser.PK_Language - 96))
                    | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                    | (1 << (SMTLIBv2Parser.PK_License - 96))
                    | (1 << (SMTLIBv2Parser.PK_Named - 96))
                    | (1 << (SMTLIBv2Parser.PK_Name - 96))
                    | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                    | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                    | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                    | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                    | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                    | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                    | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                    | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                    | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                    | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                    | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                    | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                    | (1 << (SMTLIBv2Parser.PK_Source - 96))
                    | (1 << (SMTLIBv2Parser.PK_Status - 96))
                    | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                    | (1 << (SMTLIBv2Parser.PK_Values - 96))
                    | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                    | (1 << (SMTLIBv2Parser.PK_Version - 96))
                )
            ) != 0:
                self.state = 485
                self.attribute()
                self.state = 490
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 491
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Meta_spec_constantContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GRW_Numeral(self):
            return self.getToken(SMTLIBv2Parser.GRW_Numeral, 0)

        def GRW_Decimal(self):
            return self.getToken(SMTLIBv2Parser.GRW_Decimal, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_meta_spec_constant

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMeta_spec_constant"):
                listener.enterMeta_spec_constant(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMeta_spec_constant"):
                listener.exitMeta_spec_constant(self)

    def meta_spec_constant(self):

        localctx = SMTLIBv2Parser.Meta_spec_constantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_meta_spec_constant)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 493
            _la = self._input.LA(1)
            if not (
                _la == SMTLIBv2Parser.GRW_Decimal or _la == SMTLIBv2Parser.GRW_Numeral
            ):
                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 Fun_symbol_declContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def spec_constant(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Spec_constantContext, 0)

        def sort(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SortContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, i)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, i)

        def meta_spec_constant(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Meta_spec_constantContext, 0)

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_fun_symbol_decl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFun_symbol_decl"):
                listener.enterFun_symbol_decl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFun_symbol_decl"):
                listener.exitFun_symbol_decl(self)

    def fun_symbol_decl(self):

        localctx = SMTLIBv2Parser.Fun_symbol_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_fun_symbol_decl)
        self._la = 0  # Token type
        try:
            self.state = 532
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 30, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 495
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 496
                self.spec_constant()
                self.state = 497
                self.sort()
                self.state = 501
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 498
                    self.attribute()
                    self.state = 503
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 504
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 506
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 507
                self.meta_spec_constant()
                self.state = 508
                self.sort()
                self.state = 512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 509
                    self.attribute()
                    self.state = 514
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 515
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 517
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 518
                self.identifier()
                self.state = 520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 519
                    self.sort()
                    self.state = 522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 527
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 524
                    self.attribute()
                    self.state = 529
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 530
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Par_fun_symbol_declContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fun_symbol_decl(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Fun_symbol_declContext, 0)

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def GRW_Par(self):
            return self.getToken(SMTLIBv2Parser.GRW_Par, 0)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def sort(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SortContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, i)

        def attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_par_fun_symbol_decl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPar_fun_symbol_decl"):
                listener.enterPar_fun_symbol_decl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPar_fun_symbol_decl"):
                listener.exitPar_fun_symbol_decl(self)

    def par_fun_symbol_decl(self):

        localctx = SMTLIBv2Parser.Par_fun_symbol_declContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 62, self.RULE_par_fun_symbol_decl)
        self._la = 0  # Token type
        try:
            self.state = 560
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 34, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 534
                self.fun_symbol_decl()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 535
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 536
                self.match(SMTLIBv2Parser.GRW_Par)
                self.state = 537
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 539
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 538
                    self.symbol()
                    self.state = 541
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 543
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 544
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 545
                self.identifier()
                self.state = 547
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 546
                    self.sort()
                    self.state = 549
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 554
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 551
                    self.attribute()
                    self.state = 556
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 557
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 558
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Theory_attributeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_Sorts(self):
            return self.getToken(SMTLIBv2Parser.PK_Sorts, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def sort_symbol_decl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Sort_symbol_declContext)
            else:
                return self.getTypedRuleContext(
                    SMTLIBv2Parser.Sort_symbol_declContext, i
                )

        def PK_Funs(self):
            return self.getToken(SMTLIBv2Parser.PK_Funs, 0)

        def par_fun_symbol_decl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    SMTLIBv2Parser.Par_fun_symbol_declContext
                )
            else:
                return self.getTypedRuleContext(
                    SMTLIBv2Parser.Par_fun_symbol_declContext, i
                )

        def PK_SortsDescription(self):
            return self.getToken(SMTLIBv2Parser.PK_SortsDescription, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def PK_FunsDescription(self):
            return self.getToken(SMTLIBv2Parser.PK_FunsDescription, 0)

        def PK_Definition(self):
            return self.getToken(SMTLIBv2Parser.PK_Definition, 0)

        def PK_Values(self):
            return self.getToken(SMTLIBv2Parser.PK_Values, 0)

        def PK_Notes(self):
            return self.getToken(SMTLIBv2Parser.PK_Notes, 0)

        def attribute(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_theory_attribute

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTheory_attribute"):
                listener.enterTheory_attribute(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTheory_attribute"):
                listener.exitTheory_attribute(self)

    def theory_attribute(self):

        localctx = SMTLIBv2Parser.Theory_attributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_theory_attribute)
        self._la = 0  # Token type
        try:
            self.state = 591
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 37, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 562
                self.match(SMTLIBv2Parser.PK_Sorts)
                self.state = 563
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 565
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 564
                    self.sort_symbol_decl()
                    self.state = 567
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 569
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 571
                self.match(SMTLIBv2Parser.PK_Funs)
                self.state = 572
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 573
                    self.par_fun_symbol_decl()
                    self.state = 576
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 578
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 580
                self.match(SMTLIBv2Parser.PK_SortsDescription)
                self.state = 581
                self.string()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 582
                self.match(SMTLIBv2Parser.PK_FunsDescription)
                self.state = 583
                self.string()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 584
                self.match(SMTLIBv2Parser.PK_Definition)
                self.state = 585
                self.string()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 586
                self.match(SMTLIBv2Parser.PK_Values)
                self.state = 587
                self.string()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 588
                self.match(SMTLIBv2Parser.PK_Notes)
                self.state = 589
                self.string()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 590
                self.attribute()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Theory_declContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def PS_Theory(self):
            return self.getToken(SMTLIBv2Parser.PS_Theory, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def theory_attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Theory_attributeContext)
            else:
                return self.getTypedRuleContext(
                    SMTLIBv2Parser.Theory_attributeContext, i
                )

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_theory_decl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTheory_decl"):
                listener.enterTheory_decl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTheory_decl"):
                listener.exitTheory_decl(self)

    def theory_decl(self):

        localctx = SMTLIBv2Parser.Theory_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_theory_decl)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 593
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 594
            self.match(SMTLIBv2Parser.PS_Theory)
            self.state = 595
            self.symbol()
            self.state = 597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 596
                self.theory_attribute()
                self.state = 599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 96)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 96))
                            & (
                                (1 << (SMTLIBv2Parser.Colon - 96))
                                | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                                | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                                | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                                | (1 << (SMTLIBv2Parser.PK_Category - 96))
                                | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                                | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                                | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                                | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                                | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                                | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                                | (1 << (SMTLIBv2Parser.PK_Language - 96))
                                | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_License - 96))
                                | (1 << (SMTLIBv2Parser.PK_Named - 96))
                                | (1 << (SMTLIBv2Parser.PK_Name - 96))
                                | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                                | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                                | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                                | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                                | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                                | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                                | (
                                    1
                                    << (
                                        SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96
                                    )
                                )
                                | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                                | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                                | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_Source - 96))
                                | (1 << (SMTLIBv2Parser.PK_Status - 96))
                                | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                                | (1 << (SMTLIBv2Parser.PK_Values - 96))
                                | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                                | (1 << (SMTLIBv2Parser.PK_Version - 96))
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 601
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Logic_attribueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_Theories(self):
            return self.getToken(SMTLIBv2Parser.PK_Theories, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def PK_Language(self):
            return self.getToken(SMTLIBv2Parser.PK_Language, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def PK_Extension(self):
            return self.getToken(SMTLIBv2Parser.PK_Extension, 0)

        def PK_Values(self):
            return self.getToken(SMTLIBv2Parser.PK_Values, 0)

        def PK_Notes(self):
            return self.getToken(SMTLIBv2Parser.PK_Notes, 0)

        def attribute(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_logic_attribue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLogic_attribue"):
                listener.enterLogic_attribue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLogic_attribue"):
                listener.exitLogic_attribue(self)

    def logic_attribue(self):

        localctx = SMTLIBv2Parser.Logic_attribueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_logic_attribue)
        self._la = 0  # Token type
        try:
            self.state = 621
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 40, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 603
                self.match(SMTLIBv2Parser.PK_Theories)
                self.state = 604
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 606
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 605
                    self.symbol()
                    self.state = 608
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 610
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 612
                self.match(SMTLIBv2Parser.PK_Language)
                self.state = 613
                self.string()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 614
                self.match(SMTLIBv2Parser.PK_Extension)
                self.state = 615
                self.string()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 616
                self.match(SMTLIBv2Parser.PK_Values)
                self.state = 617
                self.string()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 618
                self.match(SMTLIBv2Parser.PK_Notes)
                self.state = 619
                self.string()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 620
                self.attribute()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LogicContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def PS_Logic(self):
            return self.getToken(SMTLIBv2Parser.PS_Logic, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def logic_attribue(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Logic_attribueContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Logic_attribueContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_logic

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLogic"):
                listener.enterLogic(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLogic"):
                listener.exitLogic(self)

    def logic(self):

        localctx = SMTLIBv2Parser.LogicContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_logic)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 623
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 624
            self.match(SMTLIBv2Parser.PS_Logic)
            self.state = 625
            self.symbol()
            self.state = 627
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 626
                self.logic_attribue()
                self.state = 629
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 96)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 96))
                            & (
                                (1 << (SMTLIBv2Parser.Colon - 96))
                                | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                                | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                                | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                                | (1 << (SMTLIBv2Parser.PK_Category - 96))
                                | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                                | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                                | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                                | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                                | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                                | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                                | (1 << (SMTLIBv2Parser.PK_Language - 96))
                                | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_License - 96))
                                | (1 << (SMTLIBv2Parser.PK_Named - 96))
                                | (1 << (SMTLIBv2Parser.PK_Name - 96))
                                | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                                | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                                | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                                | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                                | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                                | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                                | (
                                    1
                                    << (
                                        SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96
                                    )
                                )
                                | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                                | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                                | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_Source - 96))
                                | (1 << (SMTLIBv2Parser.PK_Status - 96))
                                | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                                | (1 << (SMTLIBv2Parser.PK_Values - 96))
                                | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                                | (1 << (SMTLIBv2Parser.PK_Version - 96))
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 631
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Sort_decContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_sort_dec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSort_dec"):
                listener.enterSort_dec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSort_dec"):
                listener.exitSort_dec(self)

    def sort_dec(self):

        localctx = SMTLIBv2Parser.Sort_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_sort_dec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 633
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 634
            self.symbol()
            self.state = 635
            self.numeral()
            self.state = 636
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Selector_decContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def sort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_selector_dec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSelector_dec"):
                listener.enterSelector_dec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSelector_dec"):
                listener.exitSelector_dec(self)

    def selector_dec(self):

        localctx = SMTLIBv2Parser.Selector_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_selector_dec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 638
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 639
            self.symbol()
            self.state = 640
            self.sort()
            self.state = 641
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Constructor_decContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def selector_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Selector_decContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Selector_decContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_constructor_dec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstructor_dec"):
                listener.enterConstructor_dec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstructor_dec"):
                listener.exitConstructor_dec(self)

    def constructor_dec(self):

        localctx = SMTLIBv2Parser.Constructor_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_constructor_dec)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 643
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 644
            self.symbol()
            self.state = 648
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 645
                self.selector_dec()
                self.state = 650
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 651
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Datatype_decContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def constructor_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Constructor_decContext)
            else:
                return self.getTypedRuleContext(
                    SMTLIBv2Parser.Constructor_decContext, i
                )

        def GRW_Par(self):
            return self.getToken(SMTLIBv2Parser.GRW_Par, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_datatype_dec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDatatype_dec"):
                listener.enterDatatype_dec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDatatype_dec"):
                listener.exitDatatype_dec(self)

    def datatype_dec(self):

        localctx = SMTLIBv2Parser.Datatype_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_datatype_dec)
        self._la = 0  # Token type
        try:
            self.state = 679
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 46, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 653
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 655
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 654
                    self.constructor_dec()
                    self.state = 657
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 659
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 661
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 662
                self.match(SMTLIBv2Parser.GRW_Par)
                self.state = 663
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 665
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 664
                    self.symbol()
                    self.state = 667
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 669
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 670
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 672
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 671
                    self.constructor_dec()
                    self.state = 674
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 676
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 677
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Function_decContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def sort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, 0)

        def sorted_var(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Sorted_varContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Sorted_varContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_function_dec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFunction_dec"):
                listener.enterFunction_dec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFunction_dec"):
                listener.exitFunction_dec(self)

    def function_dec(self):

        localctx = SMTLIBv2Parser.Function_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_function_dec)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 681
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 682
            self.symbol()
            self.state = 683
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 687
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 684
                self.sorted_var()
                self.state = 689
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 690
            self.match(SMTLIBv2Parser.ParClose)
            self.state = 691
            self.sort()
            self.state = 692
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Function_defContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def sort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, 0)

        def term(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, 0)

        def sorted_var(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Sorted_varContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Sorted_varContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_function_def

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFunction_def"):
                listener.enterFunction_def(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFunction_def"):
                listener.exitFunction_def(self)

    def function_def(self):

        localctx = SMTLIBv2Parser.Function_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_function_def)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 694
            self.symbol()
            self.state = 695
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 699
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 696
                self.sorted_var()
                self.state = 701
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 702
            self.match(SMTLIBv2Parser.ParClose)
            self.state = 703
            self.sort()
            self.state = 704
            self.term()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Prop_literalContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def PS_Not(self):
            return self.getToken(SMTLIBv2Parser.PS_Not, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_prop_literal

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterProp_literal"):
                listener.enterProp_literal(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitProp_literal"):
                listener.exitProp_literal(self)

    def prop_literal(self):

        localctx = SMTLIBv2Parser.Prop_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_prop_literal)
        try:
            self.state = 712
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                SMTLIBv2Parser.QuotedSymbol,
                SMTLIBv2Parser.PS_Not,
                SMTLIBv2Parser.PS_Bool,
                SMTLIBv2Parser.PS_Int,
                SMTLIBv2Parser.PS_Real,
                SMTLIBv2Parser.PS_ContinuedExecution,
                SMTLIBv2Parser.PS_Error,
                SMTLIBv2Parser.PS_False,
                SMTLIBv2Parser.PS_ImmediateExit,
                SMTLIBv2Parser.PS_Incomplete,
                SMTLIBv2Parser.PS_Logic,
                SMTLIBv2Parser.PS_Memout,
                SMTLIBv2Parser.PS_Sat,
                SMTLIBv2Parser.PS_Success,
                SMTLIBv2Parser.PS_Theory,
                SMTLIBv2Parser.PS_True,
                SMTLIBv2Parser.PS_Unknown,
                SMTLIBv2Parser.PS_Unsupported,
                SMTLIBv2Parser.PS_Unsat,
                SMTLIBv2Parser.UndefinedSymbol,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 706
                self.symbol()
                pass
            elif token in [SMTLIBv2Parser.ParOpen]:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 708
                self.match(SMTLIBv2Parser.PS_Not)
                self.state = 709
                self.symbol()
                self.state = 710
                self.match(SMTLIBv2Parser.ParClose)
                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 ScriptContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def command(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.CommandContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.CommandContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_script

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterScript"):
                listener.enterScript(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitScript"):
                listener.exitScript(self)

    def script(self):

        localctx = SMTLIBv2Parser.ScriptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_script)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 717
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 714
                self.command()
                self.state = 719
                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 Cmd_assertContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Assert(self):
            return self.getToken(SMTLIBv2Parser.CMD_Assert, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_assert

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_assert"):
                listener.enterCmd_assert(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_assert"):
                listener.exitCmd_assert(self)

    def cmd_assert(self):

        localctx = SMTLIBv2Parser.Cmd_assertContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_cmd_assert)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.match(SMTLIBv2Parser.CMD_Assert)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_assertSoftContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_AssertSoft(self):
            return self.getToken(SMTLIBv2Parser.CMD_AssertSoft, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_assertSoft

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_assertSoft"):
                listener.enterCmd_assertSoft(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_assertSoft"):
                listener.exitCmd_assertSoft(self)

    def cmd_assertSoft(self):

        localctx = SMTLIBv2Parser.Cmd_assertSoftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_cmd_assertSoft)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 722
            self.match(SMTLIBv2Parser.CMD_AssertSoft)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_simplifyContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Simplify(self):
            return self.getToken(SMTLIBv2Parser.Simplify, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_simplify

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_simplify"):
                listener.enterCmd_simplify(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_simplify"):
                listener.exitCmd_simplify(self)

    def cmd_simplify(self):

        localctx = SMTLIBv2Parser.Cmd_simplifyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_cmd_simplify)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 724
            self.match(SMTLIBv2Parser.Simplify)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_checkSatContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_CheckSat(self):
            return self.getToken(SMTLIBv2Parser.CMD_CheckSat, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_checkSat

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_checkSat"):
                listener.enterCmd_checkSat(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_checkSat"):
                listener.exitCmd_checkSat(self)

    def cmd_checkSat(self):

        localctx = SMTLIBv2Parser.Cmd_checkSatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_cmd_checkSat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 726
            self.match(SMTLIBv2Parser.CMD_CheckSat)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_checkSatAssumingContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_CheckSatAssuming(self):
            return self.getToken(SMTLIBv2Parser.CMD_CheckSatAssuming, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_checkSatAssuming

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_checkSatAssuming"):
                listener.enterCmd_checkSatAssuming(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_checkSatAssuming"):
                listener.exitCmd_checkSatAssuming(self)

    def cmd_checkSatAssuming(self):

        localctx = SMTLIBv2Parser.Cmd_checkSatAssumingContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 96, self.RULE_cmd_checkSatAssuming)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.match(SMTLIBv2Parser.CMD_CheckSatAssuming)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_checkSatUsingContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_CheckSatUsing(self):
            return self.getToken(SMTLIBv2Parser.CMD_CheckSatUsing, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_checkSatUsing

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_checkSatUsing"):
                listener.enterCmd_checkSatUsing(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_checkSatUsing"):
                listener.exitCmd_checkSatUsing(self)

    def cmd_checkSatUsing(self):

        localctx = SMTLIBv2Parser.Cmd_checkSatUsingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_cmd_checkSatUsing)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730
            self.match(SMTLIBv2Parser.CMD_CheckSatUsing)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_minimizeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Minimize(self):
            return self.getToken(SMTLIBv2Parser.CMD_Minimize, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_minimize

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_minimize"):
                listener.enterCmd_minimize(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_minimize"):
                listener.exitCmd_minimize(self)

    def cmd_minimize(self):

        localctx = SMTLIBv2Parser.Cmd_minimizeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_cmd_minimize)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 732
            self.match(SMTLIBv2Parser.CMD_Minimize)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_maximizeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Maximize(self):
            return self.getToken(SMTLIBv2Parser.CMD_Maximize, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_maximize

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_maximize"):
                listener.enterCmd_maximize(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_maximize"):
                listener.exitCmd_maximize(self)

    def cmd_maximize(self):

        localctx = SMTLIBv2Parser.Cmd_maximizeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_cmd_maximize)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 734
            self.match(SMTLIBv2Parser.CMD_Maximize)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareConstContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareConst(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareConst, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareConst

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareConst"):
                listener.enterCmd_declareConst(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareConst"):
                listener.exitCmd_declareConst(self)

    def cmd_declareConst(self):

        localctx = SMTLIBv2Parser.Cmd_declareConstContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_cmd_declareConst)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            self.match(SMTLIBv2Parser.CMD_DeclareConst)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareDatatypeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareDatatype(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareDatatype, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareDatatype

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareDatatype"):
                listener.enterCmd_declareDatatype(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareDatatype"):
                listener.exitCmd_declareDatatype(self)

    def cmd_declareDatatype(self):

        localctx = SMTLIBv2Parser.Cmd_declareDatatypeContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 106, self.RULE_cmd_declareDatatype)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 738
            self.match(SMTLIBv2Parser.CMD_DeclareDatatype)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareCodatatypeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareCodatatype(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareCodatatype, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareCodatatype

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareCodatatype"):
                listener.enterCmd_declareCodatatype(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareCodatatype"):
                listener.exitCmd_declareCodatatype(self)

    def cmd_declareCodatatype(self):

        localctx = SMTLIBv2Parser.Cmd_declareCodatatypeContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 108, self.RULE_cmd_declareCodatatype)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 740
            self.match(SMTLIBv2Parser.CMD_DeclareCodatatype)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareDatatypesContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareDatatypes(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareDatatypes, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareDatatypes

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareDatatypes"):
                listener.enterCmd_declareDatatypes(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareDatatypes"):
                listener.exitCmd_declareDatatypes(self)

    def cmd_declareDatatypes(self):

        localctx = SMTLIBv2Parser.Cmd_declareDatatypesContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 110, self.RULE_cmd_declareDatatypes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 742
            self.match(SMTLIBv2Parser.CMD_DeclareDatatypes)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareCodatatypesContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareCodatatypes(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareCodatatypes, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareCodatatypes

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareCodatatypes"):
                listener.enterCmd_declareCodatatypes(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareCodatatypes"):
                listener.exitCmd_declareCodatatypes(self)

    def cmd_declareCodatatypes(self):

        localctx = SMTLIBv2Parser.Cmd_declareCodatatypesContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 112, self.RULE_cmd_declareCodatatypes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(SMTLIBv2Parser.CMD_DeclareCodatatypes)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareFunContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareFun(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareFun, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareFun

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareFun"):
                listener.enterCmd_declareFun(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareFun"):
                listener.exitCmd_declareFun(self)

    def cmd_declareFun(self):

        localctx = SMTLIBv2Parser.Cmd_declareFunContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_cmd_declareFun)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 746
            self.match(SMTLIBv2Parser.CMD_DeclareFun)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_declareSortContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DeclareSort(self):
            return self.getToken(SMTLIBv2Parser.CMD_DeclareSort, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_declareSort

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_declareSort"):
                listener.enterCmd_declareSort(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_declareSort"):
                listener.exitCmd_declareSort(self)

    def cmd_declareSort(self):

        localctx = SMTLIBv2Parser.Cmd_declareSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_cmd_declareSort)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 748
            self.match(SMTLIBv2Parser.CMD_DeclareSort)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Define(self):
            return self.getToken(SMTLIBv2Parser.CMD_Define, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_define

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_define"):
                listener.enterCmd_define(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_define"):
                listener.exitCmd_define(self)

    def cmd_define(self):

        localctx = SMTLIBv2Parser.Cmd_defineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_cmd_define)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 750
            self.match(SMTLIBv2Parser.CMD_Define)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineFunContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DefineFun(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFun, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_defineFun

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_defineFun"):
                listener.enterCmd_defineFun(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_defineFun"):
                listener.exitCmd_defineFun(self)

    def cmd_defineFun(self):

        localctx = SMTLIBv2Parser.Cmd_defineFunContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_cmd_defineFun)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 752
            self.match(SMTLIBv2Parser.CMD_DefineFun)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineConstContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DefineConst(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineConst, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_defineConst

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_defineConst"):
                listener.enterCmd_defineConst(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_defineConst"):
                listener.exitCmd_defineConst(self)

    def cmd_defineConst(self):

        localctx = SMTLIBv2Parser.Cmd_defineConstContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_cmd_defineConst)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 754
            self.match(SMTLIBv2Parser.CMD_DefineConst)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineFunRecContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DefineFunRec(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFunRec, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_defineFunRec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_defineFunRec"):
                listener.enterCmd_defineFunRec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_defineFunRec"):
                listener.exitCmd_defineFunRec(self)

    def cmd_defineFunRec(self):

        localctx = SMTLIBv2Parser.Cmd_defineFunRecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_cmd_defineFunRec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 756
            self.match(SMTLIBv2Parser.CMD_DefineFunRec)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineFunsRecContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DefineFunsRec(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFunsRec, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_defineFunsRec

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_defineFunsRec"):
                listener.enterCmd_defineFunsRec(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_defineFunsRec"):
                listener.exitCmd_defineFunsRec(self)

    def cmd_defineFunsRec(self):

        localctx = SMTLIBv2Parser.Cmd_defineFunsRecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_cmd_defineFunsRec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 758
            self.match(SMTLIBv2Parser.CMD_DefineFunsRec)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_defineSortContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_DefineSort(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineSort, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_defineSort

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_defineSort"):
                listener.enterCmd_defineSort(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_defineSort"):
                listener.exitCmd_defineSort(self)

    def cmd_defineSort(self):

        localctx = SMTLIBv2Parser.Cmd_defineSortContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_cmd_defineSort)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 760
            self.match(SMTLIBv2Parser.CMD_DefineSort)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_displayContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Display(self):
            return self.getToken(SMTLIBv2Parser.CMD_Display, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_display

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_display"):
                listener.enterCmd_display(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_display"):
                listener.exitCmd_display(self)

    def cmd_display(self):

        localctx = SMTLIBv2Parser.Cmd_displayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_cmd_display)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 762
            self.match(SMTLIBv2Parser.CMD_Display)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_echoContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Echo(self):
            return self.getToken(SMTLIBv2Parser.CMD_Echo, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_echo

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_echo"):
                listener.enterCmd_echo(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_echo"):
                listener.exitCmd_echo(self)

    def cmd_echo(self):

        localctx = SMTLIBv2Parser.Cmd_echoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_cmd_echo)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 764
            self.match(SMTLIBv2Parser.CMD_Echo)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_evalContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Eval(self):
            return self.getToken(SMTLIBv2Parser.CMD_Eval, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_eval

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_eval"):
                listener.enterCmd_eval(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_eval"):
                listener.exitCmd_eval(self)

    def cmd_eval(self):

        localctx = SMTLIBv2Parser.Cmd_evalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_cmd_eval)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 766
            self.match(SMTLIBv2Parser.CMD_Eval)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_exitContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Exit(self):
            return self.getToken(SMTLIBv2Parser.CMD_Exit, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_exit

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_exit"):
                listener.enterCmd_exit(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_exit"):
                listener.exitCmd_exit(self)

    def cmd_exit(self):

        localctx = SMTLIBv2Parser.Cmd_exitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_cmd_exit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 768
            self.match(SMTLIBv2Parser.CMD_Exit)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_GetObjectivesContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetObjectives(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetObjectives, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_GetObjectives

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_GetObjectives"):
                listener.enterCmd_GetObjectives(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_GetObjectives"):
                listener.exitCmd_GetObjectives(self)

    def cmd_GetObjectives(self):

        localctx = SMTLIBv2Parser.Cmd_GetObjectivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_cmd_GetObjectives)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 770
            self.match(SMTLIBv2Parser.CMD_GetObjectives)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getAssertionsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetAssertions(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetAssertions, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getAssertions

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getAssertions"):
                listener.enterCmd_getAssertions(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getAssertions"):
                listener.exitCmd_getAssertions(self)

    def cmd_getAssertions(self):

        localctx = SMTLIBv2Parser.Cmd_getAssertionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_cmd_getAssertions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 772
            self.match(SMTLIBv2Parser.CMD_GetAssertions)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getAssignmentContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetAssignment(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetAssignment, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getAssignment

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getAssignment"):
                listener.enterCmd_getAssignment(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getAssignment"):
                listener.exitCmd_getAssignment(self)

    def cmd_getAssignment(self):

        localctx = SMTLIBv2Parser.Cmd_getAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_cmd_getAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 774
            self.match(SMTLIBv2Parser.CMD_GetAssignment)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getInfoContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetInfo(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetInfo, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getInfo

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getInfo"):
                listener.enterCmd_getInfo(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getInfo"):
                listener.exitCmd_getInfo(self)

    def cmd_getInfo(self):

        localctx = SMTLIBv2Parser.Cmd_getInfoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_cmd_getInfo)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 776
            self.match(SMTLIBv2Parser.CMD_GetInfo)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getModelContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetModel(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetModel, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getModel

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getModel"):
                listener.enterCmd_getModel(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getModel"):
                listener.exitCmd_getModel(self)

    def cmd_getModel(self):

        localctx = SMTLIBv2Parser.Cmd_getModelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_cmd_getModel)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 778
            self.match(SMTLIBv2Parser.CMD_GetModel)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_blockModelContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_BlockModel(self):
            return self.getToken(SMTLIBv2Parser.CMD_BlockModel, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_blockModel

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_blockModel"):
                listener.enterCmd_blockModel(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_blockModel"):
                listener.exitCmd_blockModel(self)

    def cmd_blockModel(self):

        localctx = SMTLIBv2Parser.Cmd_blockModelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_cmd_blockModel)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 780
            self.match(SMTLIBv2Parser.CMD_BlockModel)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getOptionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetOption(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetOption, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getOption

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getOption"):
                listener.enterCmd_getOption(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getOption"):
                listener.exitCmd_getOption(self)

    def cmd_getOption(self):

        localctx = SMTLIBv2Parser.Cmd_getOptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_cmd_getOption)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 782
            self.match(SMTLIBv2Parser.CMD_GetOption)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getProofContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetProof(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetProof, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getProof

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getProof"):
                listener.enterCmd_getProof(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getProof"):
                listener.exitCmd_getProof(self)

    def cmd_getProof(self):

        localctx = SMTLIBv2Parser.Cmd_getProofContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_cmd_getProof)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 784
            self.match(SMTLIBv2Parser.CMD_GetProof)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getUnsatAssumptionsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetUnsatAssumptions(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetUnsatAssumptions, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getUnsatAssumptions

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getUnsatAssumptions"):
                listener.enterCmd_getUnsatAssumptions(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getUnsatAssumptions"):
                listener.exitCmd_getUnsatAssumptions(self)

    def cmd_getUnsatAssumptions(self):

        localctx = SMTLIBv2Parser.Cmd_getUnsatAssumptionsContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 154, self.RULE_cmd_getUnsatAssumptions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 786
            self.match(SMTLIBv2Parser.CMD_GetUnsatAssumptions)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_labelsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Labels(self):
            return self.getToken(SMTLIBv2Parser.CMD_Labels, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_labels

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_labels"):
                listener.enterCmd_labels(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_labels"):
                listener.exitCmd_labels(self)

    def cmd_labels(self):

        localctx = SMTLIBv2Parser.Cmd_labelsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_cmd_labels)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 788
            self.match(SMTLIBv2Parser.CMD_Labels)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getUnsatCoreContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetUnsatCore(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetUnsatCore, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getUnsatCore

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getUnsatCore"):
                listener.enterCmd_getUnsatCore(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getUnsatCore"):
                listener.exitCmd_getUnsatCore(self)

    def cmd_getUnsatCore(self):

        localctx = SMTLIBv2Parser.Cmd_getUnsatCoreContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_cmd_getUnsatCore)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 790
            self.match(SMTLIBv2Parser.CMD_GetUnsatCore)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_getValueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_GetValue(self):
            return self.getToken(SMTLIBv2Parser.CMD_GetValue, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_getValue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_getValue"):
                listener.enterCmd_getValue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_getValue"):
                listener.exitCmd_getValue(self)

    def cmd_getValue(self):

        localctx = SMTLIBv2Parser.Cmd_getValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_cmd_getValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 792
            self.match(SMTLIBv2Parser.CMD_GetValue)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_popContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Pop(self):
            return self.getToken(SMTLIBv2Parser.CMD_Pop, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_pop

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_pop"):
                listener.enterCmd_pop(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_pop"):
                listener.exitCmd_pop(self)

    def cmd_pop(self):

        localctx = SMTLIBv2Parser.Cmd_popContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_cmd_pop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 794
            self.match(SMTLIBv2Parser.CMD_Pop)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_poly_factorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_PolyFactor(self):
            return self.getToken(SMTLIBv2Parser.CMD_PolyFactor, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_poly_factor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_poly_factor"):
                listener.enterCmd_poly_factor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_poly_factor"):
                listener.exitCmd_poly_factor(self)

    def cmd_poly_factor(self):

        localctx = SMTLIBv2Parser.Cmd_poly_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_cmd_poly_factor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 796
            self.match(SMTLIBv2Parser.CMD_PolyFactor)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_pushContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Push(self):
            return self.getToken(SMTLIBv2Parser.CMD_Push, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_push

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_push"):
                listener.enterCmd_push(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_push"):
                listener.exitCmd_push(self)

    def cmd_push(self):

        localctx = SMTLIBv2Parser.Cmd_pushContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_cmd_push)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 798
            self.match(SMTLIBv2Parser.CMD_Push)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_resetContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_Reset(self):
            return self.getToken(SMTLIBv2Parser.CMD_Reset, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_reset

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_reset"):
                listener.enterCmd_reset(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_reset"):
                listener.exitCmd_reset(self)

    def cmd_reset(self):

        localctx = SMTLIBv2Parser.Cmd_resetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_cmd_reset)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 800
            self.match(SMTLIBv2Parser.CMD_Reset)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_resetAssertionsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_ResetAssertions(self):
            return self.getToken(SMTLIBv2Parser.CMD_ResetAssertions, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_resetAssertions

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_resetAssertions"):
                listener.enterCmd_resetAssertions(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_resetAssertions"):
                listener.exitCmd_resetAssertions(self)

    def cmd_resetAssertions(self):

        localctx = SMTLIBv2Parser.Cmd_resetAssertionsContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 170, self.RULE_cmd_resetAssertions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 802
            self.match(SMTLIBv2Parser.CMD_ResetAssertions)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_setInfoContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_SetInfo(self):
            return self.getToken(SMTLIBv2Parser.CMD_SetInfo, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_setInfo

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_setInfo"):
                listener.enterCmd_setInfo(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_setInfo"):
                listener.exitCmd_setInfo(self)

    def cmd_setInfo(self):

        localctx = SMTLIBv2Parser.Cmd_setInfoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_cmd_setInfo)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 804
            self.match(SMTLIBv2Parser.CMD_SetInfo)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_setLogicContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_SetLogic(self):
            return self.getToken(SMTLIBv2Parser.CMD_SetLogic, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_setLogic

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_setLogic"):
                listener.enterCmd_setLogic(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_setLogic"):
                listener.exitCmd_setLogic(self)

    def cmd_setLogic(self):

        localctx = SMTLIBv2Parser.Cmd_setLogicContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_cmd_setLogic)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 806
            self.match(SMTLIBv2Parser.CMD_SetLogic)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Cmd_setOptionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CMD_SetOption(self):
            return self.getToken(SMTLIBv2Parser.CMD_SetOption, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_cmd_setOption

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCmd_setOption"):
                listener.enterCmd_setOption(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCmd_setOption"):
                listener.exitCmd_setOption(self)

    def cmd_setOption(self):

        localctx = SMTLIBv2Parser.Cmd_setOptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_cmd_setOption)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 808
            self.match(SMTLIBv2Parser.CMD_SetOption)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Tac_thenContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_Then(self):
            return self.getToken(SMTLIBv2Parser.TAC_Then, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_tac_then

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTac_then"):
                listener.enterTac_then(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTac_then"):
                listener.exitTac_then(self)

    def tac_then(self):

        localctx = SMTLIBv2Parser.Tac_thenContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_tac_then)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 810
            self.match(SMTLIBv2Parser.TAC_Then)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Tac_and_thenContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_AndThen(self):
            return self.getToken(SMTLIBv2Parser.TAC_AndThen, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_tac_and_then

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTac_and_then"):
                listener.enterTac_and_then(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTac_and_then"):
                listener.exitTac_and_then(self)

    def tac_and_then(self):

        localctx = SMTLIBv2Parser.Tac_and_thenContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_tac_and_then)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 812
            self.match(SMTLIBv2Parser.TAC_AndThen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Par_thenContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_ParThen(self):
            return self.getToken(SMTLIBv2Parser.TAC_ParThen, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_par_then

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPar_then"):
                listener.enterPar_then(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPar_then"):
                listener.exitPar_then(self)

    def par_then(self):

        localctx = SMTLIBv2Parser.Par_thenContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_par_then)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 814
            self.match(SMTLIBv2Parser.TAC_ParThen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Or_elseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_OrElse(self):
            return self.getToken(SMTLIBv2Parser.TAC_OrElse, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_or_else

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOr_else"):
                listener.enterOr_else(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOr_else"):
                listener.exitOr_else(self)

    def or_else(self):

        localctx = SMTLIBv2Parser.Or_elseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_or_else)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 816
            self.match(SMTLIBv2Parser.TAC_OrElse)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Par_or_elseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_ParOrElse(self):
            return self.getToken(SMTLIBv2Parser.TAC_ParOrElse, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_par_or_else

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPar_or_else"):
                listener.enterPar_or_else(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPar_or_else"):
                listener.exitPar_or_else(self)

    def par_or_else(self):

        localctx = SMTLIBv2Parser.Par_or_elseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_par_or_else)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            self.match(SMTLIBv2Parser.TAC_ParOrElse)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Par_orContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_ParOr(self):
            return self.getToken(SMTLIBv2Parser.TAC_ParOr, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_par_or

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPar_or"):
                listener.enterPar_or(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPar_or"):
                listener.exitPar_or(self)

    def par_or(self):

        localctx = SMTLIBv2Parser.Par_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_par_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 820
            self.match(SMTLIBv2Parser.TAC_ParOr)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TryForContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_TryFor(self):
            return self.getToken(SMTLIBv2Parser.TAC_TryFor, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_tryFor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTryFor"):
                listener.enterTryFor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTryFor"):
                listener.exitTryFor(self)

    def tryFor(self):

        localctx = SMTLIBv2Parser.TryForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_tryFor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 822
            self.match(SMTLIBv2Parser.TAC_TryFor)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class UsingParamsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TAC_UsingParams(self):
            return self.getToken(SMTLIBv2Parser.TAC_UsingParams, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_usingParams

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterUsingParams"):
                listener.enterUsingParams(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitUsingParams"):
                listener.exitUsingParams(self)

    def usingParams(self):

        localctx = SMTLIBv2Parser.UsingParamsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_usingParams)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 824
            self.match(SMTLIBv2Parser.TAC_UsingParams)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TacticalContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.IdentifierContext, 0)

        def Simplify(self):
            return self.getToken(SMTLIBv2Parser.Simplify, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def GRW_Exclamation(self):
            return self.getToken(SMTLIBv2Parser.GRW_Exclamation, 0)

        def tactical(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TacticalContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TacticalContext, i)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def attribute(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, 0)

        def tac_then(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Tac_thenContext, 0)

        def tac_and_then(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Tac_and_thenContext, 0)

        def par_then(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Par_thenContext, 0)

        def or_else(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Or_elseContext, 0)

        def par_or_else(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Par_or_elseContext, 0)

        def par_or(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Par_orContext, 0)

        def tryFor(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.TryForContext, 0)

        def decimal(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.DecimalContext, 0)

        def usingParams(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.UsingParamsContext, 0)

        def cmd_echo(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_echoContext, 0)

        def string(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.StringContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, i)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_tactical

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTactical"):
                listener.enterTactical(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTactical"):
                listener.exitTactical(self)

    def tactical(self):

        localctx = SMTLIBv2Parser.TacticalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_tactical)
        self._la = 0  # Token type
        try:
            self.state = 918
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 61, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 826
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 827
                self.match(SMTLIBv2Parser.Simplify)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 828
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 829
                self.match(SMTLIBv2Parser.GRW_Exclamation)
                self.state = 830
                self.tactical()
                self.state = 832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 831
                    self.attribute()

                self.state = 834
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 836
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 837
                self.tac_then()
                self.state = 839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 838
                    self.tactical()
                    self.state = 841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                    | (1 << SMTLIBv2Parser.Simplify)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 843
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 845
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 846
                self.tac_and_then()
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 847
                    self.tactical()
                    self.state = 850
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                    | (1 << SMTLIBv2Parser.Simplify)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 852
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 854
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 855
                self.par_then()
                self.state = 857
                self._errHandler.sync(self)
                _alt = 1
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 856
                        self.tactical()

                    else:
                        raise NoViableAltException(self)
                    self.state = 859
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 54, self._ctx)

                self.state = 861
                self.tactical()
                self.state = 862
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 864
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 865
                self.or_else()
                self.state = 867
                self._errHandler.sync(self)
                _alt = 1
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 866
                        self.tactical()

                    else:
                        raise NoViableAltException(self)
                    self.state = 869
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 55, self._ctx)

                self.state = 871
                self.tactical()
                self.state = 872
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 874
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 875
                self.par_or_else()
                self.state = 877
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 876
                    self.tactical()
                    self.state = 879
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                    | (1 << SMTLIBv2Parser.Simplify)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 881
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 883
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 884
                self.par_or()
                self.state = 886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 885
                    self.tactical()
                    self.state = 888
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                    | (1 << SMTLIBv2Parser.Simplify)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 890
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 892
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 893
                self.tryFor()
                self.state = 895
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 894
                    self.tactical()
                    self.state = 897
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                    | (1 << SMTLIBv2Parser.Simplify)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 899
                self.decimal()
                self.state = 900
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 902
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 903
                self.usingParams()
                self.state = 904
                self.tactical()
                self.state = 905
                self.attribute()
                self.state = 906
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 908
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 909
                self.cmd_echo()
                self.state = 912
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 912
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SMTLIBv2Parser.String]:
                        self.state = 910
                        self.string()
                        pass
                    elif token in [
                        SMTLIBv2Parser.QuotedSymbol,
                        SMTLIBv2Parser.PS_Not,
                        SMTLIBv2Parser.PS_Bool,
                        SMTLIBv2Parser.PS_Int,
                        SMTLIBv2Parser.PS_Real,
                        SMTLIBv2Parser.PS_ContinuedExecution,
                        SMTLIBv2Parser.PS_Error,
                        SMTLIBv2Parser.PS_False,
                        SMTLIBv2Parser.PS_ImmediateExit,
                        SMTLIBv2Parser.PS_Incomplete,
                        SMTLIBv2Parser.PS_Logic,
                        SMTLIBv2Parser.PS_Memout,
                        SMTLIBv2Parser.PS_Sat,
                        SMTLIBv2Parser.PS_Success,
                        SMTLIBv2Parser.PS_Theory,
                        SMTLIBv2Parser.PS_True,
                        SMTLIBv2Parser.PS_Unknown,
                        SMTLIBv2Parser.PS_Unsupported,
                        SMTLIBv2Parser.PS_Unsat,
                        SMTLIBv2Parser.UndefinedSymbol,
                    ]:
                        self.state = 911
                        self.symbol()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 914
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 916
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommandContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def cmd_assert(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_assertContext, 0)

        def term(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TermContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, i)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def cmd_assertSoft(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_assertSoftContext, 0)

        def attribute(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, i)

        def cmd_checkSat(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_checkSatContext, 0)

        def cmd_checkSatAssuming(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_checkSatAssumingContext, 0
            )

        def cmd_minimize(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_minimizeContext, 0)

        def cmd_maximize(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_maximizeContext, 0)

        def cmd_simplify(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_simplifyContext, 0)

        def cmd_declareConst(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_declareConstContext, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def sort(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SortContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SortContext, i)

        def cmd_declareDatatype(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_declareDatatypeContext, 0
            )

        def datatype_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Datatype_decContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Datatype_decContext, i)

        def cmd_declareCodatatype(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_declareCodatatypeContext, 0
            )

        def cmd_declareDatatypes(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_declareDatatypesContext, 0
            )

        def sort_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Sort_decContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Sort_decContext, i)

        def cmd_declareCodatatypes(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_declareCodatatypesContext, 0
            )

        def cmd_declareFun(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_declareFunContext, 0)

        def cmd_declareSort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_declareSortContext, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def cmd_define(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineContext, 0)

        def cmd_defineFun(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineFunContext, 0)

        def function_def(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Function_defContext, 0)

        def cmd_defineConst(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineConstContext, 0)

        def cmd_defineFunRec(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineFunRecContext, 0)

        def cmd_defineFunsRec(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineFunsRecContext, 0)

        def function_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Function_decContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Function_decContext, i)

        def cmd_display(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_displayContext, 0)

        def cmd_defineSort(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_defineSortContext, 0)

        def cmd_echo(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_echoContext, 0)

        def string(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.StringContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, i)

        def cmd_eval(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_evalContext, 0)

        def cmd_exit(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_exitContext, 0)

        def cmd_GetObjectives(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_GetObjectivesContext, 0)

        def cmd_getAssertions(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getAssertionsContext, 0)

        def cmd_getAssignment(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getAssignmentContext, 0)

        def cmd_getInfo(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getInfoContext, 0)

        def info_flag(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Info_flagContext, 0)

        def cmd_getModel(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getModelContext, 0)

        def cmd_blockModel(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_blockModelContext, 0)

        def cmd_getOption(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getOptionContext, 0)

        def keyword(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.KeywordContext, 0)

        def cmd_getProof(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getProofContext, 0)

        def cmd_getUnsatAssumptions(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_getUnsatAssumptionsContext, 0
            )

        def cmd_getUnsatCore(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getUnsatCoreContext, 0)

        def cmd_getValue(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_getValueContext, 0)

        def cmd_poly_factor(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_poly_factorContext, 0)

        def cmd_pop(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_popContext, 0)

        def cmd_push(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_pushContext, 0)

        def cmd_reset(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_resetContext, 0)

        def cmd_resetAssertions(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Cmd_resetAssertionsContext, 0
            )

        def cmd_setInfo(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_setInfoContext, 0)

        def cmd_setLogic(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_setLogicContext, 0)

        def cmd_setOption(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_setOptionContext, 0)

        def option(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.OptionContext, 0)

        def cmd_checkSatUsing(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_checkSatUsingContext, 0)

        def tactical(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.TacticalContext, 0)

        def cmd_labels(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Cmd_labelsContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_command

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCommand"):
                listener.enterCommand(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCommand"):
                listener.exitCommand(self)

    def command(self):

        localctx = SMTLIBv2Parser.CommandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_command)
        self._la = 0  # Token type
        try:
            self.state = 1244
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 78, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 920
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 921
                self.cmd_assert()
                self.state = 922
                self.term()
                self.state = 923
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 925
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 926
                self.cmd_assertSoft()
                self.state = 927
                self.term()
                self.state = 931
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 928
                    self.attribute()
                    self.state = 933
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 934
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 936
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 937
                self.cmd_checkSat()
                self.state = 941
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.ParOpen)
                            | (1 << SMTLIBv2Parser.String)
                            | (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.RegConst)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 92)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 92))
                        & (
                            (1 << (SMTLIBv2Parser.Numeral - 92))
                            | (1 << (SMTLIBv2Parser.Binary - 92))
                            | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                            | (1 << (SMTLIBv2Parser.Decimal - 92))
                            | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                        )
                    )
                    != 0
                ):
                    self.state = 938
                    self.term()
                    self.state = 943
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 944
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 946
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 947
                self.cmd_checkSatAssuming()
                self.state = 948
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.ParOpen)
                            | (1 << SMTLIBv2Parser.String)
                            | (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.RegConst)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 92)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 92))
                        & (
                            (1 << (SMTLIBv2Parser.Numeral - 92))
                            | (1 << (SMTLIBv2Parser.Binary - 92))
                            | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                            | (1 << (SMTLIBv2Parser.Decimal - 92))
                            | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                        )
                    )
                    != 0
                ):
                    self.state = 949
                    self.term()
                    self.state = 954
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 955
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 956
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 958
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 959
                self.cmd_minimize()
                self.state = 960
                self.term()
                self.state = 961
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 963
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 964
                self.cmd_maximize()
                self.state = 965
                self.term()
                self.state = 966
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 968
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 969
                self.cmd_simplify()
                self.state = 970
                self.term()
                self.state = 974
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la - 96)) & ~0x3F) == 0 and (
                    (1 << (_la - 96))
                    & (
                        (1 << (SMTLIBv2Parser.Colon - 96))
                        | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                        | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                        | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                        | (1 << (SMTLIBv2Parser.PK_Category - 96))
                        | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                        | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                        | (1 << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                        | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                        | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                        | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                        | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                        | (1 << (SMTLIBv2Parser.PK_Language - 96))
                        | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_License - 96))
                        | (1 << (SMTLIBv2Parser.PK_Named - 96))
                        | (1 << (SMTLIBv2Parser.PK_Name - 96))
                        | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                        | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                        | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96))
                        | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                        | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                        | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                        | (1 << (SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96))
                        | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                        | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                        | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                        | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                        | (1 << (SMTLIBv2Parser.PK_Source - 96))
                        | (1 << (SMTLIBv2Parser.PK_Status - 96))
                        | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                        | (1 << (SMTLIBv2Parser.PK_Values - 96))
                        | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                        | (1 << (SMTLIBv2Parser.PK_Version - 96))
                    )
                ) != 0:
                    self.state = 971
                    self.attribute()
                    self.state = 976
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 977
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 979
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 980
                self.cmd_declareConst()
                self.state = 981
                self.symbol()
                self.state = 982
                self.sort()
                self.state = 983
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 985
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 986
                self.cmd_declareDatatype()
                self.state = 987
                self.symbol()
                self.state = 988
                self.datatype_dec()
                self.state = 989
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 991
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 992
                self.cmd_declareCodatatype()
                self.state = 993
                self.symbol()
                self.state = 994
                self.datatype_dec()
                self.state = 995
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 997
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 998
                self.cmd_declareDatatypes()
                self.state = 999
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1001
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1000
                    self.sort_dec()
                    self.state = 1003
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1005
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1006
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1008
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1007
                    self.datatype_dec()
                    self.state = 1010
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1012
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1013
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1015
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1016
                self.cmd_declareCodatatypes()
                self.state = 1017
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1018
                    self.sort_dec()
                    self.state = 1021
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1023
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1024
                self.datatype_dec()
                self.state = 1025
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1026
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1028
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1027
                    self.datatype_dec()
                    self.state = 1030
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1032
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1033
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1035
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1036
                self.cmd_declareFun()
                self.state = 1037
                self.symbol()
                self.state = 1038
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1042
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.ParOpen)
                            | (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or _la == SMTLIBv2Parser.UndefinedSymbol:
                    self.state = 1039
                    self.sort()
                    self.state = 1044
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1045
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1046
                self.sort()
                self.state = 1047
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1049
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1050
                self.cmd_declareSort()
                self.state = 1051
                self.symbol()
                self.state = 1053
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == SMTLIBv2Parser.Numeral:
                    self.state = 1052
                    self.numeral()

                self.state = 1055
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1057
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1058
                self.cmd_define()
                self.state = 1059
                self.symbol()
                self.state = 1060
                self.term()
                self.state = 1061
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1063
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1064
                self.cmd_defineFun()
                self.state = 1065
                self.function_def()
                self.state = 1066
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1068
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1069
                self.cmd_defineConst()
                self.state = 1070
                self.symbol()
                self.state = 1071
                self.sort()
                self.state = 1072
                self.term()
                self.state = 1073
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1075
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1076
                self.cmd_defineFunRec()
                self.state = 1077
                self.function_def()
                self.state = 1078
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1080
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1081
                self.cmd_defineFunsRec()
                self.state = 1082
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1084
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1083
                    self.function_dec()
                    self.state = 1086
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1088
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1089
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1091
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1090
                    self.term()
                    self.state = 1093
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.RegConst)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or (
                            (((_la - 92)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 92))
                                & (
                                    (1 << (SMTLIBv2Parser.Numeral - 92))
                                    | (1 << (SMTLIBv2Parser.Binary - 92))
                                    | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                                    | (1 << (SMTLIBv2Parser.Decimal - 92))
                                    | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 1095
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1096
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1098
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1099
                self.cmd_display()
                self.state = 1100
                self.term()
                self.state = 1101
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1103
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1104
                self.cmd_defineSort()
                self.state = 1105
                self.symbol()
                self.state = 1106
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1110
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.QuotedSymbol)
                            | (1 << SMTLIBv2Parser.PS_Not)
                            | (1 << SMTLIBv2Parser.PS_Bool)
                            | (1 << SMTLIBv2Parser.PS_Int)
                            | (1 << SMTLIBv2Parser.PS_Real)
                            | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                            | (1 << SMTLIBv2Parser.PS_Error)
                            | (1 << SMTLIBv2Parser.PS_False)
                            | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                            | (1 << SMTLIBv2Parser.PS_Incomplete)
                            | (1 << SMTLIBv2Parser.PS_Logic)
                            | (1 << SMTLIBv2Parser.PS_Memout)
                            | (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Success)
                            | (1 << SMTLIBv2Parser.PS_Theory)
                            | (1 << SMTLIBv2Parser.PS_True)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsupported)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 0
                ) or _la == SMTLIBv2Parser.UndefinedSymbol:
                    self.state = 1107
                    self.symbol()
                    self.state = 1112
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1113
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1114
                self.sort()
                self.state = 1115
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1117
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1118
                self.cmd_echo()
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1121
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SMTLIBv2Parser.String]:
                        self.state = 1119
                        self.string()
                        pass
                    elif token in [
                        SMTLIBv2Parser.QuotedSymbol,
                        SMTLIBv2Parser.PS_Not,
                        SMTLIBv2Parser.PS_Bool,
                        SMTLIBv2Parser.PS_Int,
                        SMTLIBv2Parser.PS_Real,
                        SMTLIBv2Parser.PS_ContinuedExecution,
                        SMTLIBv2Parser.PS_Error,
                        SMTLIBv2Parser.PS_False,
                        SMTLIBv2Parser.PS_ImmediateExit,
                        SMTLIBv2Parser.PS_Incomplete,
                        SMTLIBv2Parser.PS_Logic,
                        SMTLIBv2Parser.PS_Memout,
                        SMTLIBv2Parser.PS_Sat,
                        SMTLIBv2Parser.PS_Success,
                        SMTLIBv2Parser.PS_Theory,
                        SMTLIBv2Parser.PS_True,
                        SMTLIBv2Parser.PS_Unknown,
                        SMTLIBv2Parser.PS_Unsupported,
                        SMTLIBv2Parser.PS_Unsat,
                        SMTLIBv2Parser.UndefinedSymbol,
                    ]:
                        self.state = 1120
                        self.symbol()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 1123
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or _la == SMTLIBv2Parser.UndefinedSymbol
                    ):
                        break

                self.state = 1125
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 1127
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1128
                self.cmd_eval()
                self.state = 1129
                self.term()
                self.state = 1130
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 1132
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1133
                self.cmd_exit()
                self.state = 1134
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 1136
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1137
                self.cmd_GetObjectives()
                self.state = 1138
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 1140
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1141
                self.cmd_getAssertions()
                self.state = 1142
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 1144
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1145
                self.cmd_getAssignment()
                self.state = 1146
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 1148
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1149
                self.cmd_getInfo()
                self.state = 1150
                self.info_flag()
                self.state = 1151
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 1153
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1154
                self.cmd_getModel()
                self.state = 1155
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 1157
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1158
                self.cmd_blockModel()
                self.state = 1159
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 1161
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1162
                self.cmd_getOption()
                self.state = 1163
                self.keyword()
                self.state = 1164
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 1166
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1167
                self.cmd_getProof()
                self.state = 1168
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 1170
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1171
                self.cmd_getUnsatAssumptions()
                self.state = 1172
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 1174
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1175
                self.cmd_getUnsatCore()
                self.state = 1176
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 1178
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1179
                self.cmd_getValue()
                self.state = 1180
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1182
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1181
                    self.term()
                    self.state = 1184
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.RegConst)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or (
                            (((_la - 92)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 92))
                                & (
                                    (1 << (SMTLIBv2Parser.Numeral - 92))
                                    | (1 << (SMTLIBv2Parser.Binary - 92))
                                    | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                                    | (1 << (SMTLIBv2Parser.Decimal - 92))
                                    | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 1186
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1187
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 1189
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1190
                self.cmd_poly_factor()
                self.state = 1191
                self.term()
                self.state = 1192
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 1194
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1195
                self.cmd_pop()
                self.state = 1196
                self.numeral()
                self.state = 1197
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 1199
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1200
                self.cmd_pop()
                self.state = 1201
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 1203
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1204
                self.cmd_push()
                self.state = 1205
                self.numeral()
                self.state = 1206
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 1208
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1209
                self.cmd_push()
                self.state = 1210
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 1212
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1213
                self.cmd_reset()
                self.state = 1214
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 42:
                self.enterOuterAlt(localctx, 42)
                self.state = 1216
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1217
                self.cmd_resetAssertions()
                self.state = 1218
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 43:
                self.enterOuterAlt(localctx, 43)
                self.state = 1220
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1221
                self.cmd_setInfo()
                self.state = 1222
                self.attribute()
                self.state = 1223
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 1225
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1226
                self.cmd_setLogic()
                self.state = 1227
                self.symbol()
                self.state = 1228
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 45:
                self.enterOuterAlt(localctx, 45)
                self.state = 1230
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1231
                self.cmd_setOption()
                self.state = 1232
                self.option()
                self.state = 1233
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 46:
                self.enterOuterAlt(localctx, 46)
                self.state = 1235
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1236
                self.cmd_checkSatUsing()
                self.state = 1237
                self.tactical()
                self.state = 1238
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 47:
                self.enterOuterAlt(localctx, 47)
                self.state = 1240
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1241
                self.cmd_labels()
                self.state = 1242
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class B_valueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_True(self):
            return self.getToken(SMTLIBv2Parser.PS_True, 0)

        def PS_False(self):
            return self.getToken(SMTLIBv2Parser.PS_False, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_b_value

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterB_value"):
                listener.enterB_value(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitB_value"):
                listener.exitB_value(self)

    def b_value(self):

        localctx = SMTLIBv2Parser.B_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_b_value)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1246
            _la = self._input.LA(1)
            if not (_la == SMTLIBv2Parser.PS_False or _la == SMTLIBv2Parser.PS_True):
                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 OptionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_DiagnosticOutputChannel(self):
            return self.getToken(SMTLIBv2Parser.PK_DiagnosticOutputChannel, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def PK_GlobalDeclarations(self):
            return self.getToken(SMTLIBv2Parser.PK_GlobalDeclarations, 0)

        def b_value(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.B_valueContext, 0)

        def PK_InteractiveMode(self):
            return self.getToken(SMTLIBv2Parser.PK_InteractiveMode, 0)

        def PK_PrintSuccess(self):
            return self.getToken(SMTLIBv2Parser.PK_PrintSuccess, 0)

        def PK_ProduceAssertions(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceAssertions, 0)

        def PK_ProduceAssignments(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceAssignments, 0)

        def PK_ProduceModels(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceModels, 0)

        def PK_ProduceProofs(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceProofs, 0)

        def PK_ProduceUnsatAssumptions(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceUnsatAssumptions, 0)

        def PK_ProduceUnsatCores(self):
            return self.getToken(SMTLIBv2Parser.PK_ProduceUnsatCores, 0)

        def PK_RandomSeed(self):
            return self.getToken(SMTLIBv2Parser.PK_RandomSeed, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def PK_RegularOutputChannel(self):
            return self.getToken(SMTLIBv2Parser.PK_RegularOutputChannel, 0)

        def PK_ReproducibleResourceLimit(self):
            return self.getToken(SMTLIBv2Parser.PK_ReproducibleResourceLimit, 0)

        def PK_Verbosity(self):
            return self.getToken(SMTLIBv2Parser.PK_Verbosity, 0)

        def attribute(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_option

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOption"):
                listener.enterOption(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOption"):
                listener.exitOption(self)

    def option(self):

        localctx = SMTLIBv2Parser.OptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_option)
        try:
            self.state = 1277
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 79, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1248
                self.match(SMTLIBv2Parser.PK_DiagnosticOutputChannel)
                self.state = 1249
                self.string()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1250
                self.match(SMTLIBv2Parser.PK_GlobalDeclarations)
                self.state = 1251
                self.b_value()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1252
                self.match(SMTLIBv2Parser.PK_InteractiveMode)
                self.state = 1253
                self.b_value()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1254
                self.match(SMTLIBv2Parser.PK_PrintSuccess)
                self.state = 1255
                self.b_value()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1256
                self.match(SMTLIBv2Parser.PK_ProduceAssertions)
                self.state = 1257
                self.b_value()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1258
                self.match(SMTLIBv2Parser.PK_ProduceAssignments)
                self.state = 1259
                self.b_value()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1260
                self.match(SMTLIBv2Parser.PK_ProduceModels)
                self.state = 1261
                self.b_value()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1262
                self.match(SMTLIBv2Parser.PK_ProduceProofs)
                self.state = 1263
                self.b_value()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1264
                self.match(SMTLIBv2Parser.PK_ProduceUnsatAssumptions)
                self.state = 1265
                self.b_value()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1266
                self.match(SMTLIBv2Parser.PK_ProduceUnsatCores)
                self.state = 1267
                self.b_value()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1268
                self.match(SMTLIBv2Parser.PK_RandomSeed)
                self.state = 1269
                self.numeral()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1270
                self.match(SMTLIBv2Parser.PK_RegularOutputChannel)
                self.state = 1271
                self.string()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1272
                self.match(SMTLIBv2Parser.PK_ReproducibleResourceLimit)
                self.state = 1273
                self.numeral()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1274
                self.match(SMTLIBv2Parser.PK_Verbosity)
                self.state = 1275
                self.numeral()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1276
                self.attribute()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Info_flagContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_AllStatistics(self):
            return self.getToken(SMTLIBv2Parser.PK_AllStatistics, 0)

        def PK_AssertionStackLevels(self):
            return self.getToken(SMTLIBv2Parser.PK_AssertionStackLevels, 0)

        def PK_Authors(self):
            return self.getToken(SMTLIBv2Parser.PK_Authors, 0)

        def PK_ErrorBehaviour(self):
            return self.getToken(SMTLIBv2Parser.PK_ErrorBehaviour, 0)

        def PK_Name(self):
            return self.getToken(SMTLIBv2Parser.PK_Name, 0)

        def PK_ReasonUnknown(self):
            return self.getToken(SMTLIBv2Parser.PK_ReasonUnknown, 0)

        def PK_Version(self):
            return self.getToken(SMTLIBv2Parser.PK_Version, 0)

        def keyword(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.KeywordContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_info_flag

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInfo_flag"):
                listener.enterInfo_flag(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInfo_flag"):
                listener.exitInfo_flag(self)

    def info_flag(self):

        localctx = SMTLIBv2Parser.Info_flagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_info_flag)
        try:
            self.state = 1287
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 80, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1279
                self.match(SMTLIBv2Parser.PK_AllStatistics)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1280
                self.match(SMTLIBv2Parser.PK_AssertionStackLevels)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1281
                self.match(SMTLIBv2Parser.PK_Authors)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1282
                self.match(SMTLIBv2Parser.PK_ErrorBehaviour)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1283
                self.match(SMTLIBv2Parser.PK_Name)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1284
                self.match(SMTLIBv2Parser.PK_ReasonUnknown)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1285
                self.match(SMTLIBv2Parser.PK_Version)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1286
                self.keyword()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Error_behaviourContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_ImmediateExit(self):
            return self.getToken(SMTLIBv2Parser.PS_ImmediateExit, 0)

        def PS_ContinuedExecution(self):
            return self.getToken(SMTLIBv2Parser.PS_ContinuedExecution, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_error_behaviour

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterError_behaviour"):
                listener.enterError_behaviour(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitError_behaviour"):
                listener.exitError_behaviour(self)

    def error_behaviour(self):

        localctx = SMTLIBv2Parser.Error_behaviourContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_error_behaviour)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1289
            _la = self._input.LA(1)
            if not (
                _la == SMTLIBv2Parser.PS_ContinuedExecution
                or _la == SMTLIBv2Parser.PS_ImmediateExit
            ):
                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 Reason_unknownContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_Memout(self):
            return self.getToken(SMTLIBv2Parser.PS_Memout, 0)

        def PS_Incomplete(self):
            return self.getToken(SMTLIBv2Parser.PS_Incomplete, 0)

        def s_expr(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.S_exprContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_reason_unknown

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterReason_unknown"):
                listener.enterReason_unknown(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitReason_unknown"):
                listener.exitReason_unknown(self)

    def reason_unknown(self):

        localctx = SMTLIBv2Parser.Reason_unknownContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_reason_unknown)
        try:
            self.state = 1294
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 81, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1291
                self.match(SMTLIBv2Parser.PS_Memout)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1292
                self.match(SMTLIBv2Parser.PS_Incomplete)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1293
                self.s_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 Model_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParOpen)
            else:
                return self.getToken(SMTLIBv2Parser.ParOpen, i)

        def CMD_DefineFun(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFun, 0)

        def function_def(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Function_defContext, 0)

        def ParClose(self, i: int = None):
            if i is None:
                return self.getTokens(SMTLIBv2Parser.ParClose)
            else:
                return self.getToken(SMTLIBv2Parser.ParClose, i)

        def CMD_DefineFunRec(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFunRec, 0)

        def CMD_DefineFunsRec(self):
            return self.getToken(SMTLIBv2Parser.CMD_DefineFunsRec, 0)

        def function_dec(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Function_decContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Function_decContext, i)

        def term(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TermContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_model_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterModel_response"):
                listener.enterModel_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitModel_response"):
                listener.exitModel_response(self)

    def model_response(self):

        localctx = SMTLIBv2Parser.Model_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_model_response)
        self._la = 0  # Token type
        try:
            self.state = 1324
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 84, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1296
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1297
                self.match(SMTLIBv2Parser.CMD_DefineFun)
                self.state = 1298
                self.function_def()
                self.state = 1299
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1301
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1302
                self.match(SMTLIBv2Parser.CMD_DefineFunRec)
                self.state = 1303
                self.function_def()
                self.state = 1304
                self.match(SMTLIBv2Parser.ParClose)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1306
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1307
                self.match(SMTLIBv2Parser.CMD_DefineFunsRec)
                self.state = 1308
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1310
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1309
                    self.function_dec()
                    self.state = 1312
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la == SMTLIBv2Parser.ParOpen):
                        break

                self.state = 1314
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1315
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1317
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1316
                    self.term()
                    self.state = 1319
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << SMTLIBv2Parser.ParOpen)
                                    | (1 << SMTLIBv2Parser.String)
                                    | (1 << SMTLIBv2Parser.QuotedSymbol)
                                    | (1 << SMTLIBv2Parser.RegConst)
                                    | (1 << SMTLIBv2Parser.PS_Not)
                                    | (1 << SMTLIBv2Parser.PS_Bool)
                                    | (1 << SMTLIBv2Parser.PS_Int)
                                    | (1 << SMTLIBv2Parser.PS_Real)
                                    | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                                    | (1 << SMTLIBv2Parser.PS_Error)
                                    | (1 << SMTLIBv2Parser.PS_False)
                                    | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                                    | (1 << SMTLIBv2Parser.PS_Incomplete)
                                    | (1 << SMTLIBv2Parser.PS_Logic)
                                    | (1 << SMTLIBv2Parser.PS_Memout)
                                    | (1 << SMTLIBv2Parser.PS_Sat)
                                    | (1 << SMTLIBv2Parser.PS_Success)
                                    | (1 << SMTLIBv2Parser.PS_Theory)
                                    | (1 << SMTLIBv2Parser.PS_True)
                                    | (1 << SMTLIBv2Parser.PS_Unknown)
                                    | (1 << SMTLIBv2Parser.PS_Unsupported)
                                    | (1 << SMTLIBv2Parser.PS_Unsat)
                                )
                            )
                            != 0
                        )
                        or (
                            (((_la - 92)) & ~0x3F) == 0
                            and (
                                (1 << (_la - 92))
                                & (
                                    (1 << (SMTLIBv2Parser.Numeral - 92))
                                    | (1 << (SMTLIBv2Parser.Binary - 92))
                                    | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                                    | (1 << (SMTLIBv2Parser.Decimal - 92))
                                    | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                                )
                            )
                            != 0
                        )
                    ):
                        break

                self.state = 1321
                self.match(SMTLIBv2Parser.ParClose)
                self.state = 1322
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Info_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PK_AssertionStackLevels(self):
            return self.getToken(SMTLIBv2Parser.PK_AssertionStackLevels, 0)

        def numeral(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.NumeralContext, 0)

        def PK_Authors(self):
            return self.getToken(SMTLIBv2Parser.PK_Authors, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def PK_ErrorBehaviour(self):
            return self.getToken(SMTLIBv2Parser.PK_ErrorBehaviour, 0)

        def error_behaviour(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Error_behaviourContext, 0)

        def PK_Name(self):
            return self.getToken(SMTLIBv2Parser.PK_Name, 0)

        def PK_ReasonUnknown(self):
            return self.getToken(SMTLIBv2Parser.PK_ReasonUnknown, 0)

        def reason_unknown(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Reason_unknownContext, 0)

        def PK_Version(self):
            return self.getToken(SMTLIBv2Parser.PK_Version, 0)

        def attribute(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.AttributeContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_info_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInfo_response"):
                listener.enterInfo_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInfo_response"):
                listener.exitInfo_response(self)

    def info_response(self):

        localctx = SMTLIBv2Parser.Info_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_info_response)
        try:
            self.state = 1339
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 85, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1326
                self.match(SMTLIBv2Parser.PK_AssertionStackLevels)
                self.state = 1327
                self.numeral()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1328
                self.match(SMTLIBv2Parser.PK_Authors)
                self.state = 1329
                self.string()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1330
                self.match(SMTLIBv2Parser.PK_ErrorBehaviour)
                self.state = 1331
                self.error_behaviour()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1332
                self.match(SMTLIBv2Parser.PK_Name)
                self.state = 1333
                self.string()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1334
                self.match(SMTLIBv2Parser.PK_ReasonUnknown)
                self.state = 1335
                self.reason_unknown()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1336
                self.match(SMTLIBv2Parser.PK_Version)
                self.state = 1337
                self.string()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1338
                self.attribute()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Valuation_pairContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def term(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TermContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, i)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_valuation_pair

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterValuation_pair"):
                listener.enterValuation_pair(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitValuation_pair"):
                listener.exitValuation_pair(self)

    def valuation_pair(self):

        localctx = SMTLIBv2Parser.Valuation_pairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_valuation_pair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1341
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1342
            self.term()
            self.state = 1343
            self.term()
            self.state = 1344
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class T_valuation_pairContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def symbol(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, 0)

        def b_value(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.B_valueContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_t_valuation_pair

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterT_valuation_pair"):
                listener.enterT_valuation_pair(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitT_valuation_pair"):
                listener.exitT_valuation_pair(self)

    def t_valuation_pair(self):

        localctx = SMTLIBv2Parser.T_valuation_pairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_t_valuation_pair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1346
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1347
            self.symbol()
            self.state = 1348
            self.b_value()
            self.state = 1349
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Check_sat_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_Sat(self):
            return self.getToken(SMTLIBv2Parser.PS_Sat, 0)

        def PS_Unsat(self):
            return self.getToken(SMTLIBv2Parser.PS_Unsat, 0)

        def PS_Unknown(self):
            return self.getToken(SMTLIBv2Parser.PS_Unknown, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_check_sat_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCheck_sat_response"):
                listener.enterCheck_sat_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCheck_sat_response"):
                listener.exitCheck_sat_response(self)

    def check_sat_response(self):

        localctx = SMTLIBv2Parser.Check_sat_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_check_sat_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1351
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << SMTLIBv2Parser.PS_Sat)
                            | (1 << SMTLIBv2Parser.PS_Unknown)
                            | (1 << SMTLIBv2Parser.PS_Unsat)
                        )
                    )
                    != 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 Echo_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_echo_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEcho_response"):
                listener.enterEcho_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEcho_response"):
                listener.exitEcho_response(self)

    def echo_response(self):

        localctx = SMTLIBv2Parser.Echo_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_echo_response)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1353
            self.string()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_assertions_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def term(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.TermContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.TermContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_assertions_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_assertions_response"):
                listener.enterGet_assertions_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_assertions_response"):
                listener.exitGet_assertions_response(self)

    def get_assertions_response(self):

        localctx = SMTLIBv2Parser.Get_assertions_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 220, self.RULE_get_assertions_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1355
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1359
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << SMTLIBv2Parser.ParOpen)
                        | (1 << SMTLIBv2Parser.String)
                        | (1 << SMTLIBv2Parser.QuotedSymbol)
                        | (1 << SMTLIBv2Parser.RegConst)
                        | (1 << SMTLIBv2Parser.PS_Not)
                        | (1 << SMTLIBv2Parser.PS_Bool)
                        | (1 << SMTLIBv2Parser.PS_Int)
                        | (1 << SMTLIBv2Parser.PS_Real)
                        | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                        | (1 << SMTLIBv2Parser.PS_Error)
                        | (1 << SMTLIBv2Parser.PS_False)
                        | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                        | (1 << SMTLIBv2Parser.PS_Incomplete)
                        | (1 << SMTLIBv2Parser.PS_Logic)
                        | (1 << SMTLIBv2Parser.PS_Memout)
                        | (1 << SMTLIBv2Parser.PS_Sat)
                        | (1 << SMTLIBv2Parser.PS_Success)
                        | (1 << SMTLIBv2Parser.PS_Theory)
                        | (1 << SMTLIBv2Parser.PS_True)
                        | (1 << SMTLIBv2Parser.PS_Unknown)
                        | (1 << SMTLIBv2Parser.PS_Unsupported)
                        | (1 << SMTLIBv2Parser.PS_Unsat)
                    )
                )
                != 0
            ) or (
                (((_la - 92)) & ~0x3F) == 0
                and (
                    (1 << (_la - 92))
                    & (
                        (1 << (SMTLIBv2Parser.Numeral - 92))
                        | (1 << (SMTLIBv2Parser.Binary - 92))
                        | (1 << (SMTLIBv2Parser.HexDecimal - 92))
                        | (1 << (SMTLIBv2Parser.Decimal - 92))
                        | (1 << (SMTLIBv2Parser.UndefinedSymbol - 92))
                    )
                )
                != 0
            ):
                self.state = 1356
                self.term()
                self.state = 1361
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1362
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_assignment_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def t_valuation_pair(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.T_valuation_pairContext)
            else:
                return self.getTypedRuleContext(
                    SMTLIBv2Parser.T_valuation_pairContext, i
                )

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_assignment_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_assignment_response"):
                listener.enterGet_assignment_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_assignment_response"):
                listener.exitGet_assignment_response(self)

    def get_assignment_response(self):

        localctx = SMTLIBv2Parser.Get_assignment_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 222, self.RULE_get_assignment_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1364
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1368
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 1365
                self.t_valuation_pair()
                self.state = 1370
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1371
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_info_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def info_response(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Info_responseContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Info_responseContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_info_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_info_response"):
                listener.enterGet_info_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_info_response"):
                listener.exitGet_info_response(self)

    def get_info_response(self):

        localctx = SMTLIBv2Parser.Get_info_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_get_info_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1373
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1374
                self.info_response()
                self.state = 1377
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 96)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 96))
                            & (
                                (1 << (SMTLIBv2Parser.Colon - 96))
                                | (1 << (SMTLIBv2Parser.PK_AllStatistics - 96))
                                | (1 << (SMTLIBv2Parser.PK_AssertionStackLevels - 96))
                                | (1 << (SMTLIBv2Parser.PK_Authors - 96))
                                | (1 << (SMTLIBv2Parser.PK_Category - 96))
                                | (1 << (SMTLIBv2Parser.PK_Chainable - 96))
                                | (1 << (SMTLIBv2Parser.PK_Definition - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_DiagnosticOutputChannel - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ErrorBehaviour - 96))
                                | (1 << (SMTLIBv2Parser.PK_Extension - 96))
                                | (1 << (SMTLIBv2Parser.PK_Funs - 96))
                                | (1 << (SMTLIBv2Parser.PK_FunsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_GlobalDeclarations - 96))
                                | (1 << (SMTLIBv2Parser.PK_InteractiveMode - 96))
                                | (1 << (SMTLIBv2Parser.PK_Language - 96))
                                | (1 << (SMTLIBv2Parser.PK_LeftAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_License - 96))
                                | (1 << (SMTLIBv2Parser.PK_Named - 96))
                                | (1 << (SMTLIBv2Parser.PK_Name - 96))
                                | (1 << (SMTLIBv2Parser.PK_Notes - 96))
                                | (1 << (SMTLIBv2Parser.PK_Pattern - 96))
                                | (1 << (SMTLIBv2Parser.PK_PrintSuccess - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssertions - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceAssignments - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceModels - 96))
                                | (1 << (SMTLIBv2Parser.PK_ProduceProofs - 96))
                                | (
                                    1
                                    << (SMTLIBv2Parser.PK_ProduceUnsatAssumptions - 96)
                                )
                                | (1 << (SMTLIBv2Parser.PK_ProduceUnsatCores - 96))
                                | (1 << (SMTLIBv2Parser.PK_RandomSeed - 96))
                                | (1 << (SMTLIBv2Parser.PK_ReasonUnknown - 96))
                                | (1 << (SMTLIBv2Parser.PK_RegularOutputChannel - 96))
                                | (
                                    1
                                    << (
                                        SMTLIBv2Parser.PK_ReproducibleResourceLimit - 96
                                    )
                                )
                                | (1 << (SMTLIBv2Parser.PK_RightAssoc - 96))
                                | (1 << (SMTLIBv2Parser.PK_SmtLibVersion - 96))
                                | (1 << (SMTLIBv2Parser.PK_Sorts - 96))
                                | (1 << (SMTLIBv2Parser.PK_SortsDescription - 96))
                                | (1 << (SMTLIBv2Parser.PK_Source - 96))
                                | (1 << (SMTLIBv2Parser.PK_Status - 96))
                                | (1 << (SMTLIBv2Parser.PK_Theories - 96))
                                | (1 << (SMTLIBv2Parser.PK_Values - 96))
                                | (1 << (SMTLIBv2Parser.PK_Verbosity - 96))
                                | (1 << (SMTLIBv2Parser.PK_Version - 96))
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 1379
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_model_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def model_response(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Model_responseContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Model_responseContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_model_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_model_response"):
                listener.enterGet_model_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_model_response"):
                listener.exitGet_model_response(self)

    def get_model_response(self):

        localctx = SMTLIBv2Parser.Get_model_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_get_model_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1381
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == SMTLIBv2Parser.ParOpen:
                self.state = 1382
                self.model_response()
                self.state = 1387
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1388
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_option_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute_value(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Attribute_valueContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_option_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_option_response"):
                listener.enterGet_option_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_option_response"):
                listener.exitGet_option_response(self)

    def get_option_response(self):

        localctx = SMTLIBv2Parser.Get_option_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 228, self.RULE_get_option_response)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1390
            self.attribute_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_proof_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def s_expr(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.S_exprContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_proof_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_proof_response"):
                listener.enterGet_proof_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_proof_response"):
                listener.exitGet_proof_response(self)

    def get_proof_response(self):

        localctx = SMTLIBv2Parser.Get_proof_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_get_proof_response)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1392
            self.s_expr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_unsat_assump_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_unsat_assump_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_unsat_assump_response"):
                listener.enterGet_unsat_assump_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_unsat_assump_response"):
                listener.exitGet_unsat_assump_response(self)

    def get_unsat_assump_response(self):

        localctx = SMTLIBv2Parser.Get_unsat_assump_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 232, self.RULE_get_unsat_assump_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1394
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << SMTLIBv2Parser.QuotedSymbol)
                        | (1 << SMTLIBv2Parser.PS_Not)
                        | (1 << SMTLIBv2Parser.PS_Bool)
                        | (1 << SMTLIBv2Parser.PS_Int)
                        | (1 << SMTLIBv2Parser.PS_Real)
                        | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                        | (1 << SMTLIBv2Parser.PS_Error)
                        | (1 << SMTLIBv2Parser.PS_False)
                        | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                        | (1 << SMTLIBv2Parser.PS_Incomplete)
                        | (1 << SMTLIBv2Parser.PS_Logic)
                        | (1 << SMTLIBv2Parser.PS_Memout)
                        | (1 << SMTLIBv2Parser.PS_Sat)
                        | (1 << SMTLIBv2Parser.PS_Success)
                        | (1 << SMTLIBv2Parser.PS_Theory)
                        | (1 << SMTLIBv2Parser.PS_True)
                        | (1 << SMTLIBv2Parser.PS_Unknown)
                        | (1 << SMTLIBv2Parser.PS_Unsupported)
                        | (1 << SMTLIBv2Parser.PS_Unsat)
                    )
                )
                != 0
            ) or _la == SMTLIBv2Parser.UndefinedSymbol:
                self.state = 1395
                self.symbol()
                self.state = 1400
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1401
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_unsat_core_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def symbol(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.SymbolContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.SymbolContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_unsat_core_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_unsat_core_response"):
                listener.enterGet_unsat_core_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_unsat_core_response"):
                listener.exitGet_unsat_core_response(self)

    def get_unsat_core_response(self):

        localctx = SMTLIBv2Parser.Get_unsat_core_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 234, self.RULE_get_unsat_core_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1403
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1407
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << SMTLIBv2Parser.QuotedSymbol)
                        | (1 << SMTLIBv2Parser.PS_Not)
                        | (1 << SMTLIBv2Parser.PS_Bool)
                        | (1 << SMTLIBv2Parser.PS_Int)
                        | (1 << SMTLIBv2Parser.PS_Real)
                        | (1 << SMTLIBv2Parser.PS_ContinuedExecution)
                        | (1 << SMTLIBv2Parser.PS_Error)
                        | (1 << SMTLIBv2Parser.PS_False)
                        | (1 << SMTLIBv2Parser.PS_ImmediateExit)
                        | (1 << SMTLIBv2Parser.PS_Incomplete)
                        | (1 << SMTLIBv2Parser.PS_Logic)
                        | (1 << SMTLIBv2Parser.PS_Memout)
                        | (1 << SMTLIBv2Parser.PS_Sat)
                        | (1 << SMTLIBv2Parser.PS_Success)
                        | (1 << SMTLIBv2Parser.PS_Theory)
                        | (1 << SMTLIBv2Parser.PS_True)
                        | (1 << SMTLIBv2Parser.PS_Unknown)
                        | (1 << SMTLIBv2Parser.PS_Unsupported)
                        | (1 << SMTLIBv2Parser.PS_Unsat)
                    )
                )
                != 0
            ) or _la == SMTLIBv2Parser.UndefinedSymbol:
                self.state = 1404
                self.symbol()
                self.state = 1409
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1410
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Get_value_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def valuation_pair(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(SMTLIBv2Parser.Valuation_pairContext)
            else:
                return self.getTypedRuleContext(SMTLIBv2Parser.Valuation_pairContext, i)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_get_value_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGet_value_response"):
                listener.enterGet_value_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGet_value_response"):
                listener.exitGet_value_response(self)

    def get_value_response(self):

        localctx = SMTLIBv2Parser.Get_value_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_get_value_response)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1412
            self.match(SMTLIBv2Parser.ParOpen)
            self.state = 1414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1413
                self.valuation_pair()
                self.state = 1416
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la == SMTLIBv2Parser.ParOpen):
                    break

            self.state = 1418
            self.match(SMTLIBv2Parser.ParClose)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Specific_success_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def check_sat_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Check_sat_responseContext, 0)

        def echo_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Echo_responseContext, 0)

        def get_assertions_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Get_assertions_responseContext, 0
            )

        def get_assignment_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Get_assignment_responseContext, 0
            )

        def get_info_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Get_info_responseContext, 0)

        def get_model_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Get_model_responseContext, 0)

        def get_option_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Get_option_responseContext, 0
            )

        def get_proof_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Get_proof_responseContext, 0)

        def get_unsat_assump_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Get_unsat_assump_responseContext, 0
            )

        def get_unsat_core_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Get_unsat_core_responseContext, 0
            )

        def get_value_response(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.Get_value_responseContext, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_specific_success_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSpecific_success_response"):
                listener.enterSpecific_success_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSpecific_success_response"):
                listener.exitSpecific_success_response(self)

    def specific_success_response(self):

        localctx = SMTLIBv2Parser.Specific_success_responseContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 238, self.RULE_specific_success_response)
        try:
            self.state = 1431
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 93, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1420
                self.check_sat_response()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1421
                self.echo_response()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1422
                self.get_assertions_response()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1423
                self.get_assignment_response()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1424
                self.get_info_response()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1425
                self.get_model_response()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1426
                self.get_option_response()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1427
                self.get_proof_response()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1428
                self.get_unsat_assump_response()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1429
                self.get_unsat_core_response()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1430
                self.get_value_response()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class General_responseContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PS_Success(self):
            return self.getToken(SMTLIBv2Parser.PS_Success, 0)

        def specific_success_response(self):
            return self.getTypedRuleContext(
                SMTLIBv2Parser.Specific_success_responseContext, 0
            )

        def PS_Unsupported(self):
            return self.getToken(SMTLIBv2Parser.PS_Unsupported, 0)

        def ParOpen(self):
            return self.getToken(SMTLIBv2Parser.ParOpen, 0)

        def PS_Error(self):
            return self.getToken(SMTLIBv2Parser.PS_Error, 0)

        def string(self):
            return self.getTypedRuleContext(SMTLIBv2Parser.StringContext, 0)

        def ParClose(self):
            return self.getToken(SMTLIBv2Parser.ParClose, 0)

        def getRuleIndex(self):
            return SMTLIBv2Parser.RULE_general_response

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGeneral_response"):
                listener.enterGeneral_response(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGeneral_response"):
                listener.exitGeneral_response(self)

    def general_response(self):

        localctx = SMTLIBv2Parser.General_responseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_general_response)
        try:
            self.state = 1441
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 94, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1433
                self.match(SMTLIBv2Parser.PS_Success)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1434
                self.specific_success_response()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1435
                self.match(SMTLIBv2Parser.PS_Unsupported)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1436
                self.match(SMTLIBv2Parser.ParOpen)
                self.state = 1437
                self.match(SMTLIBv2Parser.PS_Error)
                self.state = 1438
                self.string()
                self.state = 1439
                self.match(SMTLIBv2Parser.ParClose)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx
