Parser for Solidity (Python) [CC: André Storhaug the genius!]

solidity_parser.py

# Generated from Solidity.g4 by ANTLR 4.9.3
# encoding: utf-8
# CC: André Storhaug; https://github.com/andstor/solidity-universal-parser mwah!
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\u008a")
        buf.write("\u04b6\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\3\2\5\2\u00c6\n\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\3\2\7\2\u00d0\n\2\f\2\16\2\u00d3\13\2\3")
        buf.write("\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\6\3\6\5\6")
        buf.write("\u00e2\n\6\3\7\3\7\5\7\u00e6\n\7\3\b\3\b\3\t\5\t\u00eb")
        buf.write("\n\t\3\t\3\t\3\n\3\n\3\n\5\n\u00f2\n\n\3\13\3\13\3\13")
        buf.write("\3\13\5\13\u00f8\n\13\3\13\3\13\3\13\3\13\5\13\u00fe\n")
        buf.write("\13\3\13\3\13\5\13\u0102\n\13\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\13\3\13\7\13\u010c\n\13\f\13\16\13\u010f\13\13")
        buf.write("\3\13\3\13\3\13\3\13\3\13\5\13\u0116\n\13\3\f\6\f\u0119")
        buf.write("\n\f\r\f\16\f\u011a\3\f\5\f\u011e\n\f\3\r\5\r\u0121\n")
        buf.write("\r\3\r\5\r\u0124\n\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u012c")
        buf.write("\n\r\f\r\16\r\u012f\13\r\5\r\u0131\n\r\3\r\3\r\7\r\u0135")
        buf.write("\n\r\f\r\16\r\u0138\13\r\3\r\3\r\3\16\3\16\5\16\u013e")
        buf.write("\n\16\3\17\3\17\5\17\u0142\n\17\3\17\3\17\7\17\u0146\n")
        buf.write("\17\f\17\16\17\u0149\13\17\3\17\3\17\3\17\3\17\3\17\3")
        buf.write("\17\3\17\3\17\3\17\3\17\7\17\u0155\n\17\f\17\16\17\u0158")
        buf.write("\13\17\7\17\u015a\n\17\f\17\16\17\u015d\13\17\3\17\5\17")
        buf.write("\u0160\n\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5")
        buf.write("\20\u016a\n\20\3\21\3\21\7\21\u016e\n\21\f\21\16\21\u0171")
        buf.write("\13\21\3\21\3\21\3\21\5\21\u0176\n\21\3\21\3\21\3\22\3")
        buf.write("\22\3\22\3\22\3\22\5\22\u017f\n\22\3\22\3\22\3\23\3\23")
        buf.write("\3\23\3\23\3\23\3\23\3\23\3\23\7\23\u018b\n\23\f\23\16")
        buf.write("\23\u018e\13\23\5\23\u0190\n\23\3\23\3\23\3\24\3\24\3")
        buf.write("\24\3\24\3\24\3\25\3\25\3\25\5\25\u019c\n\25\3\25\3\25")
        buf.write("\3\26\3\26\3\26\5\26\u01a3\n\26\3\26\5\26\u01a6\n\26\3")
        buf.write("\27\5\27\u01a9\n\27\3\27\3\27\5\27\u01ad\n\27\3\27\3\27")
        buf.write("\3\27\5\27\u01b2\n\27\3\27\3\27\5\27\u01b6\n\27\3\30\3")
        buf.write("\30\3\30\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32")
        buf.write("\3\32\3\32\3\32\7\32\u01c7\n\32\f\32\16\32\u01ca\13\32")
        buf.write("\3\33\5\33\u01cd\n\33\3\33\3\33\3\33\3\33\5\33\u01d3\n")
        buf.write("\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u01dd")
        buf.write("\n\35\3\35\3\35\7\35\u01e1\n\35\f\35\16\35\u01e4\13\35")
        buf.write("\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u01ec\n\36\f\36\16")
        buf.write("\36\u01ef\13\36\5\36\u01f1\n\36\3\36\3\36\3\37\3\37\3")
        buf.write("\37\3\37\7\37\u01f9\n\37\f\37\16\37\u01fc\13\37\5\37\u01fe")
        buf.write("\n\37\3\37\3\37\3 \3 \5 \u0204\n \3 \5 \u0207\n \3!\3")
        buf.write("!\3!\3!\7!\u020d\n!\f!\16!\u0210\13!\5!\u0212\n!\3!\3")
        buf.write("!\3\"\3\"\5\"\u0218\n\"\3\"\5\"\u021b\n\"\3#\3#\3#\3#")
        buf.write("\7#\u0221\n#\f#\16#\u0224\13#\5#\u0226\n#\3#\3#\3$\3$")
        buf.write("\5$\u022c\n$\3%\3%\5%\u0230\n%\3%\3%\3&\3&\3&\3&\3&\3")
        buf.write("&\3&\5&\u023b\n&\3&\3&\3&\5&\u0240\n&\3&\7&\u0243\n&\f")
        buf.write("&\16&\u0246\13&\3\'\3\'\3\'\7\'\u024b\n\'\f\'\16\'\u024e")
        buf.write("\13\'\3(\3(\3(\3(\5(\u0254\n(\3(\3(\3(\3(\3)\3)\3)\3)")
        buf.write("\3)\7)\u025f\n)\f)\16)\u0262\13)\3)\3)\5)\u0266\n)\3)")
        buf.write("\3)\3)\5)\u026b\n)\3)\3)\3)\7)\u0270\n)\f)\16)\u0273\13")
        buf.write(")\3)\3)\3)\3)\3)\5)\u027a\n)\3*\3*\3+\3+\3,\3,\3-\3-\3")
        buf.write("-\7-\u0285\n-\f-\16-\u0288\13-\3-\3-\3.\3.\3.\3/\3/\3")
        buf.write("/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u029f\n/\3")
        buf.write("\60\3\60\3\60\3\60\3\60\3\60\3\60\5\60\u02a8\n\60\3\60")
        buf.write("\3\60\7\60\u02ac\n\60\f\60\16\60\u02af\13\60\3\61\3\61")
        buf.write("\5\61\u02b3\n\61\3\61\3\61\3\61\5\61\u02b8\n\61\3\61\3")
        buf.write("\61\5\61\u02bc\n\61\3\61\3\61\3\61\5\61\u02c1\n\61\3\62")
        buf.write("\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02cd")
        buf.write("\n\63\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3\67\3\67\3\67")
        buf.write("\3\67\3\67\38\38\58\u02dd\n8\39\39\39\39\59\u02e3\n9\3")
        buf.write("9\39\59\u02e7\n9\39\59\u02ea\n9\39\39\39\3:\3:\5:\u02f1")
        buf.write("\n:\3:\3:\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3=\3=\3=\3")
        buf.write(">\3>\5>\u0305\n>\3>\3>\3?\3?\3?\3@\3@\3@\3@\3A\3A\3A\3")
        buf.write("A\3A\3A\3A\5A\u0317\nA\3A\3A\5A\u031b\nA\3A\3A\3B\3B\3")
        buf.write("B\3B\3B\3B\3B\3C\5C\u0327\nC\3C\3C\5C\u032b\nC\7C\u032d")
        buf.write("\nC\fC\16C\u0330\13C\3D\3D\5D\u0334\nD\3D\7D\u0337\nD")
        buf.write("\fD\16D\u033a\13D\3D\5D\u033d\nD\3D\3D\3E\3E\3F\3F\3F")
        buf.write("\3F\3F\7F\u0348\nF\fF\16F\u034b\13F\3F\3F\3F\3F\3F\3F")
        buf.write("\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3")
        buf.write("F\3F\3F\5F\u0367\nF\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\3F\3F\3F\3F\3F\3")
        buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0396")
        buf.write("\nF\3F\3F\3F\3F\5F\u039c\nF\3F\3F\5F\u03a0\nF\3F\3F\3")
        buf.write("F\3F\3F\5F\u03a7\nF\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\7F\u03b3")
        buf.write("\nF\fF\16F\u03b6\13F\5F\u03b8\nF\3F\3F\3F\3F\3F\3F\3F")
        buf.write("\3F\7F\u03c2\nF\fF\16F\u03c5\13F\3G\3G\3G\3G\3G\3G\3G")
        buf.write("\5G\u03ce\nG\3G\3G\3G\3G\3G\5G\u03d5\nG\5G\u03d7\nG\3")
        buf.write("H\3H\3H\7H\u03dc\nH\fH\16H\u03df\13H\3I\3I\3I\7I\u03e4")
        buf.write("\nI\fI\16I\u03e7\13I\3I\5I\u03ea\nI\3J\3J\3J\3J\3K\3K")
        buf.write("\5K\u03f2\nK\3K\3K\5K\u03f6\nK\5K\u03f8\nK\3L\3L\3L\3")
        buf.write("L\3L\3M\3M\7M\u0401\nM\fM\16M\u0404\13M\3M\3M\3N\3N\3")
        buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\5N\u0419\n")
        buf.write("N\3O\3O\5O\u041d\nO\3P\3P\3P\3P\5P\u0423\nP\3P\3P\5P\u0427")
        buf.write("\nP\3P\3P\7P\u042b\nP\fP\16P\u042e\13P\3P\5P\u0431\nP")
        buf.write("\3Q\3Q\3Q\3Q\5Q\u0437\nQ\3R\3R\3R\3R\3S\3S\3S\3S\3S\5")
        buf.write("S\u0442\nS\3T\3T\3T\7T\u0447\nT\fT\16T\u044a\13T\3U\3")
        buf.write("U\3U\3V\3V\3V\3W\3W\3W\7W\u0455\nW\fW\16W\u0458\13W\3")
        buf.write("X\3X\3X\3X\3X\3X\5X\u0460\nX\3Y\3Y\3Y\3Y\5Y\u0466\nY\3")
        buf.write("Y\3Y\5Y\u046a\nY\3Y\3Y\3Z\3Z\3Z\3[\3[\3[\5[\u0474\n[\3")
        buf.write("[\3[\3[\5[\u0479\n[\3[\3[\3\\\3\\\3\\\3\\\3]\3]\3^\3^")
        buf.write("\3^\3^\3_\3_\5_\u0489\n_\3_\3_\5_\u048d\n_\7_\u048f\n")
        buf.write("_\f_\16_\u0492\13_\3_\3_\3_\3_\3_\7_\u0499\n_\f_\16_\u049c")
        buf.write("\13_\5_\u049e\n_\3_\5_\u04a1\n_\3`\3`\5`\u04a5\n`\3a\3")
        buf.write("a\5a\u04a9\na\3b\3b\3b\3b\7b\u04af\nb\fb\16b\u04b2\13")
        buf.write("b\5b\u04b4\nb\3b\2\4J\u008ac\2\4\6\b\n\f\16\20\22\24\26")
        buf.write("\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\")
        buf.write("^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a")
        buf.write("\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c")
        buf.write("\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae")
        buf.write("\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0")
        buf.write("\u00c2\2\26\3\2\5\13\3\2\24\26\5\2vx}}\177\u0080\3\2\"")
        buf.write("$\5\2{{}}\177\u0080\3\2.\60\6\2vv~~\u0081\u0081\u0083")
        buf.write("\u0083\5\2**<?hl\4\2\6\6@D\4\2DDFF\4\2CCGG\4\2\16\16I")
        buf.write("J\3\2KM\3\2\7\n\3\2PQ\4\2\13\13U_\3\2@A\5\2oprr\u0085")
        buf.write("\u0085\3\2op\5\2\17\17\60\60\u0084\u0084\2\u0537\2\u00c5")
        buf.write("\3\2\2\2\4\u00d6\3\2\2\2\6\u00d8\3\2\2\2\b\u00dd\3\2\2")
        buf.write("\2\n\u00e1\3\2\2\2\f\u00e3\3\2\2\2\16\u00e7\3\2\2\2\20")
        buf.write("\u00ea\3\2\2\2\22\u00ee\3\2\2\2\24\u0115\3\2\2\2\26\u011d")
        buf.write("\3\2\2\2\30\u0120\3\2\2\2\32\u013b\3\2\2\2\34\u015f\3")
        buf.write("\2\2\2\36\u0169\3\2\2\2 \u016b\3\2\2\2\"\u0179\3\2\2\2")
        buf.write("$\u0182\3\2\2\2&\u0193\3\2\2\2(\u0198\3\2\2\2*\u019f\3")
        buf.write("\2\2\2,\u01a8\3\2\2\2.\u01b7\3\2\2\2\60\u01ba\3\2\2\2")
        buf.write("\62\u01c8\3\2\2\2\64\u01cc\3\2\2\2\66\u01d6\3\2\2\28\u01d8")
        buf.write("\3\2\2\2:\u01e7\3\2\2\2<\u01f4\3\2\2\2>\u0201\3\2\2\2")
        buf.write("@\u0208\3\2\2\2B\u0215\3\2\2\2D\u021c\3\2\2\2F\u0229\3")
        buf.write("\2\2\2H\u022d\3\2\2\2J\u023a\3\2\2\2L\u0247\3\2\2\2N\u024f")
        buf.write("\3\2\2\2P\u0279\3\2\2\2R\u027b\3\2\2\2T\u027d\3\2\2\2")
        buf.write("V\u027f\3\2\2\2X\u0281\3\2\2\2Z\u028b\3\2\2\2\\\u029e")
        buf.write("\3\2\2\2^\u02a0\3\2\2\2`\u02c0\3\2\2\2b\u02c2\3\2\2\2")
        buf.write("d\u02c5\3\2\2\2f\u02ce\3\2\2\2h\u02d0\3\2\2\2j\u02d2\3")
        buf.write("\2\2\2l\u02d4\3\2\2\2n\u02dc\3\2\2\2p\u02de\3\2\2\2r\u02ee")
        buf.write("\3\2\2\2t\u02f4\3\2\2\2v\u02fc\3\2\2\2x\u02ff\3\2\2\2")
        buf.write("z\u0302\3\2\2\2|\u0308\3\2\2\2~\u030b\3\2\2\2\u0080\u0316")
        buf.write("\3\2\2\2\u0082\u031e\3\2\2\2\u0084\u0326\3\2\2\2\u0086")
        buf.write("\u0331\3\2\2\2\u0088\u0340\3\2\2\2\u008a\u0366\3\2\2\2")
        buf.write("\u008c\u03d6\3\2\2\2\u008e\u03d8\3\2\2\2\u0090\u03e0\3")
        buf.write("\2\2\2\u0092\u03eb\3\2\2\2\u0094\u03f7\3\2\2\2\u0096\u03f9")
        buf.write("\3\2\2\2\u0098\u03fe\3\2\2\2\u009a\u0418\3\2\2\2\u009c")
        buf.write("\u041c\3\2\2\2\u009e\u0422\3\2\2\2\u00a0\u0432\3\2\2\2")
        buf.write("\u00a2\u0438\3\2\2\2\u00a4\u0441\3\2\2\2\u00a6\u0443\3")
        buf.write("\2\2\2\u00a8\u044b\3\2\2\2\u00aa\u044e\3\2\2\2\u00ac\u0451")
        buf.write("\3\2\2\2\u00ae\u045f\3\2\2\2\u00b0\u0461\3\2\2\2\u00b2")
        buf.write("\u046d\3\2\2\2\u00b4\u0470\3\2\2\2\u00b6\u047c\3\2\2\2")
        buf.write("\u00b8\u0480\3\2\2\2\u00ba\u0482\3\2\2\2\u00bc\u04a0\3")
        buf.write("\2\2\2\u00be\u04a4\3\2\2\2\u00c0\u04a6\3\2\2\2\u00c2\u04b3")
        buf.write("\3\2\2\2\u00c4\u00c6\5\4\3\2\u00c5\u00c4\3\2\2\2\u00c5")
        buf.write("\u00c6\3\2\2\2\u00c6\u00d1\3\2\2\2\u00c7\u00d0\5\26\f")
        buf.write("\2\u00c8\u00d0\5\6\4\2\u00c9\u00d0\5\24\13\2\u00ca\u00d0")
        buf.write("\5\30\r\2\u00cb\u00d0\5,\27\2\u00cc\u00d0\5\u0082B\2\u00cd")
        buf.write("\u00d0\5$\23\2\u00ce\u00d0\58\35\2\u00cf\u00c7\3\2\2\2")
        buf.write("\u00cf\u00c8\3\2\2\2\u00cf\u00c9\3\2\2\2\u00cf\u00ca\3")
        buf.write("\2\2\2\u00cf\u00cb\3\2\2\2\u00cf\u00cc\3\2\2\2\u00cf\u00cd")
        buf.write("\3\2\2\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1")
        buf.write("\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2")
        buf.write("\u00d3\u00d1\3\2\2\2\u00d4\u00d5\7\2\2\3\u00d5\3\3\2\2")
        buf.write("\2\u00d6\u00d7\7g\2\2\u00d7\5\3\2\2\2\u00d8\u00d9\7\3")
        buf.write("\2\2\u00d9\u00da\5\b\5\2\u00da\u00db\5\n\6\2\u00db\u00dc")
        buf.write("\7\4\2\2\u00dc\7\3\2\2\2\u00dd\u00de\5\u00c2b\2\u00de")
        buf.write("\t\3\2\2\2\u00df\u00e2\5\f\7\2\u00e0\u00e2\5\u008aF\2")
        buf.write("\u00e1\u00df\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\13\3\2")
        buf.write("\2\2\u00e3\u00e5\5\20\t\2\u00e4\u00e6\5\20\t\2\u00e5\u00e4")
        buf.write("\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\r\3\2\2\2\u00e7\u00e8")
        buf.write("\t\2\2\2\u00e8\17\3\2\2\2\u00e9\u00eb\5\16\b\2\u00ea\u00e9")
        buf.write("\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec")
        buf.write("\u00ed\7m\2\2\u00ed\21\3\2\2\2\u00ee\u00f1\5\u00c2b\2")
        buf.write("\u00ef\u00f0\7\f\2\2\u00f0\u00f2\5\u00c2b\2\u00f1\u00ef")
        buf.write("\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\23\3\2\2\2\u00f3\u00f4")
        buf.write("\7\r\2\2\u00f4\u00f7\7\u0085\2\2\u00f5\u00f6\7\f\2\2\u00f6")
        buf.write("\u00f8\5\u00c2b\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2")
        buf.write("\2\2\u00f8\u00f9\3\2\2\2\u00f9\u0116\7\4\2\2\u00fa\u00fd")
        buf.write("\7\r\2\2\u00fb\u00fe\7\16\2\2\u00fc\u00fe\5\u00c2b\2\u00fd")
        buf.write("\u00fb\3\2\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3\2\2\2")
        buf.write("\u00ff\u0100\7\f\2\2\u0100\u0102\5\u00c2b\2\u0101\u00ff")
        buf.write("\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0103\3\2\2\2\u0103")
        buf.write("\u0104\7\17\2\2\u0104\u0105\7\u0085\2\2\u0105\u0116\7")
        buf.write("\4\2\2\u0106\u0107\7\r\2\2\u0107\u0108\7\20\2\2\u0108")
        buf.write("\u010d\5\22\n\2\u0109\u010a\7\21\2\2\u010a\u010c\5\22")
        buf.write("\n\2\u010b\u0109\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b")
        buf.write("\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0110\3\2\2\2\u010f")
        buf.write("\u010d\3\2\2\2\u0110\u0111\7\22\2\2\u0111\u0112\7\17\2")
        buf.write("\2\u0112\u0113\7\u0085\2\2\u0113\u0114\7\4\2\2\u0114\u0116")
        buf.write("\3\2\2\2\u0115\u00f3\3\2\2\2\u0115\u00fa\3\2\2\2\u0115")
        buf.write("\u0106\3\2\2\2\u0116\25\3\2\2\2\u0117\u0119\7\u0087\2")
        buf.write("\2\u0118\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u0118")
        buf.write("\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011e\3\2\2\2\u011c")
        buf.write("\u011e\7\u0088\2\2\u011d\u0118\3\2\2\2\u011d\u011c\3\2")
        buf.write("\2\2\u011e\27\3\2\2\2\u011f\u0121\5\26\f\2\u0120\u011f")
        buf.write("\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0123\3\2\2\2\u0122")
        buf.write("\u0124\7\23\2\2\u0123\u0122\3\2\2\2\u0123\u0124\3\2\2")
        buf.write("\2\u0124\u0125\3\2\2\2\u0125\u0126\t\3\2\2\u0126\u0130")
        buf.write("\5\u00c2b\2\u0127\u0128\7\27\2\2\u0128\u012d\5\32\16\2")
        buf.write("\u0129\u012a\7\21\2\2\u012a\u012c\5\32\16\2\u012b\u0129")
        buf.write("\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012d")
        buf.write("\u012e\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2")
        buf.write("\u0130\u0127\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\3")
        buf.write("\2\2\2\u0132\u0136\7\20\2\2\u0133\u0135\5\36\20\2\u0134")
        buf.write("\u0133\3\2\2\2\u0135\u0138\3\2\2\2\u0136\u0134\3\2\2\2")
        buf.write("\u0136\u0137\3\2\2\2\u0137\u0139\3\2\2\2\u0138\u0136\3")
        buf.write("\2\2\2\u0139\u013a\7\22\2\2\u013a\31\3\2\2\2\u013b\u013d")
        buf.write("\5L\'\2\u013c\u013e\5\34\17\2\u013d\u013c\3\2\2\2\u013d")
        buf.write("\u013e\3\2\2\2\u013e\33\3\2\2\2\u013f\u0141\7\30\2\2\u0140")
        buf.write("\u0142\5\u008aF\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2")
        buf.write("\2\2\u0142\u0147\3\2\2\2\u0143\u0144\7\21\2\2\u0144\u0146")
        buf.write("\5\u008aF\2\u0145\u0143\3\2\2\2\u0146\u0149\3\2\2\2\u0147")
        buf.write("\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2")
        buf.write("\u0149\u0147\3\2\2\2\u014a\u0160\7\31\2\2\u014b\u015b")
        buf.write("\7\32\2\2\u014c\u014d\5\u00c2b\2\u014d\u014e\7\33\2\2")
        buf.write("\u014e\u0156\5\u008aF\2\u014f\u0150\7\21\2\2\u0150\u0151")
        buf.write("\5\u00c2b\2\u0151\u0152\7\33\2\2\u0152\u0153\5\u008aF")
        buf.write("\2\u0153\u0155\3\2\2\2\u0154\u014f\3\2\2\2\u0155\u0158")
        buf.write("\3\2\2\2\u0156\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157")
        buf.write("\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0159\u014c\3\2\2\2")
        buf.write("\u015a\u015d\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015c\3")
        buf.write("\2\2\2\u015c\u015e\3\2\2\2\u015d\u015b\3\2\2\2\u015e\u0160")
        buf.write("\7\34\2\2\u015f\u013f\3\2\2\2\u015f\u014b\3\2\2\2\u0160")
        buf.write("\35\3\2\2\2\u0161\u016a\5 \21\2\u0162\u016a\5\"\22\2\u0163")
        buf.write("\u016a\5$\23\2\u0164\u016a\5&\24\2\u0165\u016a\5(\25\2")
        buf.write("\u0166\u016a\5,\27\2\u0167\u016a\5\64\33\2\u0168\u016a")
        buf.write("\58\35\2\u0169\u0161\3\2\2\2\u0169\u0162\3\2\2\2\u0169")
        buf.write("\u0163\3\2\2\2\u0169\u0164\3\2\2\2\u0169\u0165\3\2\2\2")
        buf.write("\u0169\u0166\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u0168\3")
        buf.write("\2\2\2\u016a\37\3\2\2\2\u016b\u016f\5J&\2\u016c\u016e")
        buf.write("\t\4\2\2\u016d\u016c\3\2\2\2\u016e\u0171\3\2\2\2\u016f")
        buf.write("\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0172\3\2\2\2")
        buf.write("\u0171\u016f\3\2\2\2\u0172\u0175\5\u00c2b\2\u0173\u0174")
        buf.write("\7\13\2\2\u0174\u0176\5\u008aF\2\u0175\u0173\3\2\2\2\u0175")
        buf.write("\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0178\7\4\2\2")
        buf.write("\u0178!\3\2\2\2\u0179\u017a\7\35\2\2\u017a\u017b\5\u00c2")
        buf.write("b\2\u017b\u017e\7\36\2\2\u017c\u017f\7\16\2\2\u017d\u017f")
        buf.write("\5J&\2\u017e\u017c\3\2\2\2\u017e\u017d\3\2\2\2\u017f\u0180")
        buf.write("\3\2\2\2\u0180\u0181\7\4\2\2\u0181#\3\2\2\2\u0182\u0183")
        buf.write("\7\37\2\2\u0183\u0184\5\u00c2b\2\u0184\u018f\7\20\2\2")
        buf.write("\u0185\u0186\5H%\2\u0186\u018c\7\4\2\2\u0187\u0188\5H")
        buf.write("%\2\u0188\u0189\7\4\2\2\u0189\u018b\3\2\2\2\u018a\u0187")
        buf.write("\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c")
        buf.write("\u018d\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2\2\2")
        buf.write("\u018f\u0185\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\3")
        buf.write("\2\2\2\u0191\u0192\7\22\2\2\u0192%\3\2\2\2\u0193\u0194")
        buf.write("\7 \2\2\u0194\u0195\5:\36\2\u0195\u0196\5\62\32\2\u0196")
        buf.write("\u0197\5X-\2\u0197\'\3\2\2\2\u0198\u0199\7!\2\2\u0199")
        buf.write("\u019b\5\u00c2b\2\u019a\u019c\5:\36\2\u019b\u019a\3\2")
        buf.write("\2\2\u019b\u019c\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e")
        buf.write("\5X-\2\u019e)\3\2\2\2\u019f\u01a5\5\u00c2b\2\u01a0\u01a2")
        buf.write("\7\30\2\2\u01a1\u01a3\5\u008eH\2\u01a2\u01a1\3\2\2\2\u01a2")
        buf.write("\u01a3\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a6\7\31\2")
        buf.write("\2\u01a5\u01a0\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6+\3\2")
        buf.write("\2\2\u01a7\u01a9\5\26\f\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9")
        buf.write("\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ac\t\5\2\2\u01ab")
        buf.write("\u01ad\5\u00c2b\2\u01ac\u01ab\3\2\2\2\u01ac\u01ad\3\2")
        buf.write("\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01af\5:\36\2\u01af\u01b1")
        buf.write("\5\62\32\2\u01b0\u01b2\5.\30\2\u01b1\u01b0\3\2\2\2\u01b1")
        buf.write("\u01b2\3\2\2\2\u01b2\u01b5\3\2\2\2\u01b3\u01b6\7\4\2\2")
        buf.write("\u01b4\u01b6\5X-\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2")
        buf.write("\2\2\u01b6-\3\2\2\2\u01b7\u01b8\7%\2\2\u01b8\u01b9\5:")
        buf.write("\36\2\u01b9/\3\2\2\2\u01ba\u01bb\7w\2\2\u01bb\u01bc\5")
        buf.write(":\36\2\u01bc\61\3\2\2\2\u01bd\u01c7\5*\26\2\u01be\u01c7")
        buf.write("\5V,\2\u01bf\u01c7\7{\2\2\u01c0\u01c7\7\u0080\2\2\u01c1")
        buf.write("\u01c7\7}\2\2\u01c2\u01c7\7\177\2\2\u01c3\u01c7\7w\2\2")
        buf.write("\u01c4\u01c7\5\60\31\2\u01c5\u01c7\7y\2\2\u01c6\u01bd")
        buf.write("\3\2\2\2\u01c6\u01be\3\2\2\2\u01c6\u01bf\3\2\2\2\u01c6")
        buf.write("\u01c0\3\2\2\2\u01c6\u01c1\3\2\2\2\u01c6\u01c2\3\2\2\2")
        buf.write("\u01c6\u01c3\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c5\3")
        buf.write("\2\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c8\u01c9")
        buf.write("\3\2\2\2\u01c9\63\3\2\2\2\u01ca\u01c8\3\2\2\2\u01cb\u01cd")
        buf.write("\5\26\f\2\u01cc\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd")
        buf.write("\u01ce\3\2\2\2\u01ce\u01cf\7&\2\2\u01cf\u01d0\5\u00c2")
        buf.write("b\2\u01d0\u01d2\5@!\2\u01d1\u01d3\7t\2\2\u01d2\u01d1\3")
        buf.write("\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5")
        buf.write("\7\4\2\2\u01d5\65\3\2\2\2\u01d6\u01d7\5\u00c2b\2\u01d7")
        buf.write("\67\3\2\2\2\u01d8\u01d9\7\'\2\2\u01d9\u01da\5\u00c2b\2")
        buf.write("\u01da\u01dc\7\20\2\2\u01db\u01dd\5\66\34\2\u01dc\u01db")
        buf.write("\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01e2\3\2\2\2\u01de")
        buf.write("\u01df\7\21\2\2\u01df\u01e1\5\66\34\2\u01e0\u01de\3\2")
        buf.write("\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3")
        buf.write("\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5")
        buf.write("\u01e6\7\22\2\2\u01e69\3\2\2\2\u01e7\u01f0\7\30\2\2\u01e8")
        buf.write("\u01ed\5> \2\u01e9\u01ea\7\21\2\2\u01ea\u01ec\5> \2\u01eb")
        buf.write("\u01e9\3\2\2\2\u01ec\u01ef\3\2\2\2\u01ed\u01eb\3\2\2\2")
        buf.write("\u01ed\u01ee\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef\u01ed\3")
        buf.write("\2\2\2\u01f0\u01e8\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f2")
        buf.write("\3\2\2\2\u01f2\u01f3\7\31\2\2\u01f3;\3\2\2\2\u01f4\u01fd")
        buf.write("\7\30\2\2\u01f5\u01fa\5> \2\u01f6\u01f7\7\21\2\2\u01f7")
        buf.write("\u01f9\5> \2\u01f8\u01f6\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa")
        buf.write("\u01f8\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fe\3\2\2\2")
        buf.write("\u01fc\u01fa\3\2\2\2\u01fd\u01f5\3\2\2\2\u01fd\u01fe\3")
        buf.write("\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\7\31\2\2\u0200")
        buf.write("=\3\2\2\2\u0201\u0203\5J&\2\u0202\u0204\5T+\2\u0203\u0202")
        buf.write("\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u0206\3\2\2\2\u0205")
        buf.write("\u0207\5\u00c2b\2\u0206\u0205\3\2\2\2\u0206\u0207\3\2")
        buf.write("\2\2\u0207?\3\2\2\2\u0208\u0211\7\30\2\2\u0209\u020e\5")
        buf.write("B\"\2\u020a\u020b\7\21\2\2\u020b\u020d\5B\"\2\u020c\u020a")
        buf.write("\3\2\2\2\u020d\u0210\3\2\2\2\u020e\u020c\3\2\2\2\u020e")
        buf.write("\u020f\3\2\2\2\u020f\u0212\3\2\2\2\u0210\u020e\3\2\2\2")
        buf.write("\u0211\u0209\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0213\3")
        buf.write("\2\2\2\u0213\u0214\7\31\2\2\u0214A\3\2\2\2\u0215\u0217")
        buf.write("\5J&\2\u0216\u0218\7|\2\2\u0217\u0216\3\2\2\2\u0217\u0218")
        buf.write("\3\2\2\2\u0218\u021a\3\2\2\2\u0219\u021b\5\u00c2b\2\u021a")
        buf.write("\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021bC\3\2\2\2\u021c")
        buf.write("\u0225\7\30\2\2\u021d\u0222\5F$\2\u021e\u021f\7\21\2\2")
        buf.write("\u021f\u0221\5F$\2\u0220\u021e\3\2\2\2\u0221\u0224\3\2")
        buf.write("\2\2\u0222\u0220\3\2\2\2\u0222\u0223\3\2\2\2\u0223\u0226")
        buf.write("\3\2\2\2\u0224\u0222\3\2\2\2\u0225\u021d\3\2\2\2\u0225")
        buf.write("\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\7\31\2")
        buf.write("\2\u0228E\3\2\2\2\u0229\u022b\5J&\2\u022a\u022c\5T+\2")
        buf.write("\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022cG\3\2\2")
        buf.write("\2\u022d\u022f\5J&\2\u022e\u0230\5T+\2\u022f\u022e\3\2")
        buf.write("\2\2\u022f\u0230\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0232")
        buf.write("\5\u00c2b\2\u0232I\3\2\2\2\u0233\u0234\b&\1\2\u0234\u023b")
        buf.write("\5\u0088E\2\u0235\u023b\5L\'\2\u0236\u023b\5N(\2\u0237")
        buf.write("\u023b\5P)\2\u0238\u0239\7*\2\2\u0239\u023b\7~\2\2\u023a")
        buf.write("\u0233\3\2\2\2\u023a\u0235\3\2\2\2\u023a\u0236\3\2\2\2")
        buf.write("\u023a\u0237\3\2\2\2\u023a\u0238\3\2\2\2\u023b\u0244\3")
        buf.write("\2\2\2\u023c\u023d\f\5\2\2\u023d\u023f\7(\2\2\u023e\u0240")
        buf.write("\5\u008aF\2\u023f\u023e\3\2\2\2\u023f\u0240\3\2\2\2\u0240")
        buf.write("\u0241\3\2\2\2\u0241\u0243\7)\2\2\u0242\u023c\3\2\2\2")
        buf.write("\u0243\u0246\3\2\2\2\u0244\u0242\3\2\2\2\u0244\u0245\3")
        buf.write("\2\2\2\u0245K\3\2\2\2\u0246\u0244\3\2\2\2\u0247\u024c")
        buf.write("\5\u00c2b\2\u0248\u0249\7+\2\2\u0249\u024b\5\u00c2b\2")
        buf.write("\u024a\u0248\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024a\3")
        buf.write("\2\2\2\u024c\u024d\3\2\2\2\u024dM\3\2\2\2\u024e\u024c")
        buf.write("\3\2\2\2\u024f\u0250\7,\2\2\u0250\u0253\7\30\2\2\u0251")
        buf.write("\u0254\5\u0088E\2\u0252\u0254\5L\'\2\u0253\u0251\3\2\2")
        buf.write("\2\u0253\u0252\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0256")
        buf.write("\7-\2\2\u0256\u0257\5J&\2\u0257\u0258\7\31\2\2\u0258O")
        buf.write("\3\2\2\2\u0259\u025a\7\"\2\2\u025a\u0260\5D#\2\u025b\u025f")
        buf.write("\7}\2\2\u025c\u025f\7{\2\2\u025d\u025f\5V,\2\u025e\u025b")
        buf.write("\3\2\2\2\u025e\u025c\3\2\2\2\u025e\u025d\3\2\2\2\u025f")
        buf.write("\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260\u0261\3\2\2\2")
        buf.write("\u0261\u0265\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u0264\7")
        buf.write("%\2\2\u0264\u0266\5D#\2\u0265\u0263\3\2\2\2\u0265\u0266")
        buf.write("\3\2\2\2\u0266\u027a\3\2\2\2\u0267\u0268\7\"\2\2\u0268")
        buf.write("\u026a\7\30\2\2\u0269\u026b\5:\36\2\u026a\u0269\3\2\2")
        buf.write("\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u0271")
        buf.write("\7\31\2\2\u026d\u0270\5R*\2\u026e\u0270\5V,\2\u026f\u026d")
        buf.write("\3\2\2\2\u026f\u026e\3\2\2\2\u0270\u0273\3\2\2\2\u0271")
        buf.write("\u026f\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0274\3\2\2\2")
        buf.write("\u0273\u0271\3\2\2\2\u0274\u0275\7%\2\2\u0275\u0276\7")
        buf.write("\30\2\2\u0276\u0277\5:\36\2\u0277\u0278\7\31\2\2\u0278")
        buf.write("\u027a\3\2\2\2\u0279\u0259\3\2\2\2\u0279\u0267\3\2\2\2")
        buf.write("\u027aQ\3\2\2\2\u027b\u027c\t\6\2\2\u027cS\3\2\2\2\u027d")
        buf.write("\u027e\t\7\2\2\u027eU\3\2\2\2\u027f\u0280\t\b\2\2\u0280")
        buf.write("W\3\2\2\2\u0281\u0286\7\20\2\2\u0282\u0285\5\\/\2\u0283")
        buf.write("\u0285\5Z.\2\u0284\u0282\3\2\2\2\u0284\u0283\3\2\2\2\u0285")
        buf.write("\u0288\3\2\2\2\u0286\u0284\3\2\2\2\u0286\u0287\3\2\2\2")
        buf.write("\u0287\u0289\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028a\7")
        buf.write("\22\2\2\u028aY\3\2\2\2\u028b\u028c\7\61\2\2\u028c\u028d")
        buf.write("\5X-\2\u028d[\3\2\2\2\u028e\u029f\5d\63\2\u028f\u029f")
        buf.write("\5l\67\2\u0290\u029f\5p9\2\u0291\u029f\5X-\2\u0292\u029f")
        buf.write("\5r:\2\u0293\u029f\5t;\2\u0294\u029f\5v<\2\u0295\u029f")
        buf.write("\5x=\2\u0296\u029f\5z>\2\u0297\u029f\5|?\2\u0298\u029f")
        buf.write("\5~@\2\u0299\u029f\5n8\2\u029a\u029f\5^\60\2\u029b\u029f")
        buf.write("\5`\61\2\u029c\u029f\7\u0089\2\2\u029d\u029f\7\u008a\2")
        buf.write("\2\u029e\u028e\3\2\2\2\u029e\u028f\3\2\2\2\u029e\u0290")
        buf.write("\3\2\2\2\u029e\u0291\3\2\2\2\u029e\u0292\3\2\2\2\u029e")
        buf.write("\u0293\3\2\2\2\u029e\u0294\3\2\2\2\u029e\u0295\3\2\2\2")
        buf.write("\u029e\u0296\3\2\2\2\u029e\u0297\3\2\2\2\u029e\u0298\3")
        buf.write("\2\2\2\u029e\u0299\3\2\2\2\u029e\u029a\3\2\2\2\u029e\u029b")
        buf.write("\3\2\2\2\u029e\u029c\3\2\2\2\u029e\u029d\3\2\2\2\u029f")
        buf.write("]\3\2\2\2\u02a0\u02a1\7\62\2\2\u02a1\u02a7\5\u008aF\2")
        buf.write("\u02a2\u02a3\7%\2\2\u02a3\u02a4\7\30\2\2\u02a4\u02a5\5")
        buf.write(":\36\2\u02a5\u02a6\7\31\2\2\u02a6\u02a8\3\2\2\2\u02a7")
        buf.write("\u02a2\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2\2\2")
        buf.write("\u02a9\u02ad\5X-\2\u02aa\u02ac\5`\61\2\u02ab\u02aa\3\2")
        buf.write("\2\2\u02ac\u02af\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae")
        buf.write("\3\2\2\2\u02ae_\3\2\2\2\u02af\u02ad\3\2\2\2\u02b0\u02bb")
        buf.write("\7\63\2\2\u02b1\u02b3\5\u00c2b\2\u02b2\u02b1\3\2\2\2\u02b2")
        buf.write("\u02b3\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\7\30\2")
        buf.write("\2\u02b5\u02b7\5:\36\2\u02b6\u02b8\5\26\f\2\u02b7\u02b6")
        buf.write("\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9")
        buf.write("\u02ba\7\31\2\2\u02ba\u02bc\3\2\2\2\u02bb\u02b2\3\2\2")
        buf.write("\2\u02bb\u02bc\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02c1")
        buf.write("\5X-\2\u02be\u02bf\7\63\2\2\u02bf\u02c1\5X-\2\u02c0\u02b0")
        buf.write("\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1a\3\2\2\2\u02c2\u02c3")
        buf.write("\5\u008aF\2\u02c3\u02c4\7\4\2\2\u02c4c\3\2\2\2\u02c5\u02c6")
        buf.write("\7\64\2\2\u02c6\u02c7\7\30\2\2\u02c7\u02c8\5f\64\2\u02c8")
        buf.write("\u02c9\7\31\2\2\u02c9\u02cc\5h\65\2\u02ca\u02cb\7\65\2")
        buf.write("\2\u02cb\u02cd\5j\66\2\u02cc\u02ca\3\2\2\2\u02cc\u02cd")
        buf.write("\3\2\2\2\u02cde\3\2\2\2\u02ce\u02cf\5\u008aF\2\u02cfg")
        buf.write("\3\2\2\2\u02d0\u02d1\5\\/\2\u02d1i\3\2\2\2\u02d2\u02d3")
        buf.write("\5\\/\2\u02d3k\3\2\2\2\u02d4\u02d5\7\66\2\2\u02d5\u02d6")
        buf.write("\7\30\2\2\u02d6\u02d7\5\u008aF\2\u02d7\u02d8\7\31\2\2")
        buf.write("\u02d8\u02d9\5\\/\2\u02d9m\3\2\2\2\u02da\u02dd\5\u0080")
        buf.write("A\2\u02db\u02dd\5b\62\2\u02dc\u02da\3\2\2\2\u02dc\u02db")
        buf.write("\3\2\2\2\u02ddo\3\2\2\2\u02de\u02df\7\36\2\2\u02df\u02e2")
        buf.write("\7\30\2\2\u02e0\u02e3\5n8\2\u02e1\u02e3\7\4\2\2\u02e2")
        buf.write("\u02e0\3\2\2\2\u02e2\u02e1\3\2\2\2\u02e3\u02e6\3\2\2\2")
        buf.write("\u02e4\u02e7\5b\62\2\u02e5\u02e7\7\4\2\2\u02e6\u02e4\3")
        buf.write("\2\2\2\u02e6\u02e5\3\2\2\2\u02e7\u02e9\3\2\2\2\u02e8\u02ea")
        buf.write("\5\u008aF\2\u02e9\u02e8\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea")
        buf.write("\u02eb\3\2\2\2\u02eb\u02ec\7\31\2\2\u02ec\u02ed\5\\/\2")
        buf.write("\u02edq\3\2\2\2\u02ee\u02f0\7\67\2\2\u02ef\u02f1\7\u0085")
        buf.write("\2\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f2")
        buf.write("\3\2\2\2\u02f2\u02f3\5\u0098M\2\u02f3s\3\2\2\2\u02f4\u02f5")
        buf.write("\78\2\2\u02f5\u02f6\5\\/\2\u02f6\u02f7\7\66\2\2\u02f7")
        buf.write("\u02f8\7\30\2\2\u02f8\u02f9\5\u008aF\2\u02f9\u02fa\7\31")
        buf.write("\2\2\u02fa\u02fb\7\4\2\2\u02fbu\3\2\2\2\u02fc\u02fd\7")
        buf.write("z\2\2\u02fd\u02fe\7\4\2\2\u02few\3\2\2\2\u02ff\u0300\7")
        buf.write("u\2\2\u0300\u0301\7\4\2\2\u0301y\3\2\2\2\u0302\u0304\7")
        buf.write("9\2\2\u0303\u0305\5\u008aF\2\u0304\u0303\3\2\2\2\u0304")
        buf.write("\u0305\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\7\4\2\2")
        buf.write("\u0307{\3\2\2\2\u0308\u0309\7:\2\2\u0309\u030a\7\4\2\2")
        buf.write("\u030a}\3\2\2\2\u030b\u030c\7;\2\2\u030c\u030d\5\u0096")
        buf.write("L\2\u030d\u030e\7\4\2\2\u030e\177\3\2\2\2\u030f\u0310")
        buf.write("\7<\2\2\u0310\u0317\5\u0086D\2\u0311\u0317\5H%\2\u0312")
        buf.write("\u0313\7\30\2\2\u0313\u0314\5\u0084C\2\u0314\u0315\7\31")
        buf.write("\2\2\u0315\u0317\3\2\2\2\u0316\u030f\3\2\2\2\u0316\u0311")
        buf.write("\3\2\2\2\u0316\u0312\3\2\2\2\u0317\u031a\3\2\2\2\u0318")
        buf.write("\u0319\7\13\2\2\u0319\u031b\5\u008aF\2\u031a\u0318\3\2")
        buf.write("\2\2\u031a\u031b\3\2\2\2\u031b\u031c\3\2\2\2\u031c\u031d")
        buf.write("\7\4\2\2\u031d\u0081\3\2\2\2\u031e\u031f\5J&\2\u031f\u0320")
        buf.write("\7v\2\2\u0320\u0321\5\u00c2b\2\u0321\u0322\7\13\2\2\u0322")
        buf.write("\u0323\5\u008aF\2\u0323\u0324\7\4\2\2\u0324\u0083\3\2")
        buf.write("\2\2\u0325\u0327\5H%\2\u0326\u0325\3\2\2\2\u0326\u0327")
        buf.write("\3\2\2\2\u0327\u032e\3\2\2\2\u0328\u032a\7\21\2\2\u0329")
        buf.write("\u032b\5H%\2\u032a\u0329\3\2\2\2\u032a\u032b\3\2\2\2\u032b")
        buf.write("\u032d\3\2\2\2\u032c\u0328\3\2\2\2\u032d\u0330\3\2\2\2")
        buf.write("\u032e\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0085\3")
        buf.write("\2\2\2\u0330\u032e\3\2\2\2\u0331\u0338\7\30\2\2\u0332")
        buf.write("\u0334\5\u00c2b\2\u0333\u0332\3\2\2\2\u0333\u0334\3\2")
        buf.write("\2\2\u0334\u0335\3\2\2\2\u0335\u0337\7\21\2\2\u0336\u0333")
        buf.write("\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0338")
        buf.write("\u0339\3\2\2\2\u0339\u033c\3\2\2\2\u033a\u0338\3\2\2\2")
        buf.write("\u033b\u033d\5\u00c2b\2\u033c\u033b\3\2\2\2\u033c\u033d")
        buf.write("\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u033f\7\31\2\2\u033f")
        buf.write("\u0087\3\2\2\2\u0340\u0341\t\t\2\2\u0341\u0089\3\2\2\2")
        buf.write("\u0342\u0343\bF\1\2\u0343\u0344\7(\2\2\u0344\u0349\5\u008a")
        buf.write("F\2\u0345\u0346\7\21\2\2\u0346\u0348\5\u008aF\2\u0347")
        buf.write("\u0345\3\2\2\2\u0348\u034b\3\2\2\2\u0349\u0347\3\2\2\2")
        buf.write("\u0349\u034a\3\2\2\2\u034a\u034c\3\2\2\2\u034b\u0349\3")
        buf.write("\2\2\2\u034c\u034d\7)\2\2\u034d\u0367\3\2\2\2\u034e\u034f")
        buf.write("\7~\2\2\u034f\u0367\5\34\17\2\u0350\u0351\7\u0082\2\2")
        buf.write("\u0351\u0352\7\30\2\2\u0352\u0353\5J&\2\u0353\u0354\7")
        buf.write("\31\2\2\u0354\u0367\3\2\2\2\u0355\u0356\t\n\2\2\u0356")
        buf.write("\u0367\5\u008aF\31\u0357\u0358\7E\2\2\u0358\u0367\5J&")
        buf.write("\2\u0359\u035a\7\30\2\2\u035a\u035b\5\u008aF\2\u035b\u035c")
        buf.write("\7\31\2\2\u035c\u0367\3\2\2\2\u035d\u035e\t\13\2\2\u035e")
        buf.write("\u0367\5\u008aF\24\u035f\u0360\t\f\2\2\u0360\u0367\5\u008a")
        buf.write("F\23\u0361\u0362\7B\2\2\u0362\u0367\5\u008aF\22\u0363")
        buf.write("\u0364\7\6\2\2\u0364\u0367\5\u008aF\21\u0365\u0367\5\u008c")
        buf.write("G\2\u0366\u0342\3\2\2\2\u0366\u034e\3\2\2\2\u0366\u0350")
        buf.write("\3\2\2\2\u0366\u0355\3\2\2\2\u0366\u0357\3\2\2\2\u0366")
        buf.write("\u0359\3\2\2\2\u0366\u035d\3\2\2\2\u0366\u035f\3\2\2\2")
        buf.write("\u0366\u0361\3\2\2\2\u0366\u0363\3\2\2\2\u0366\u0365\3")
        buf.write("\2\2\2\u0367\u03c3\3\2\2\2\u0368\u0369\f\20\2\2\u0369")
        buf.write("\u036a\7H\2\2\u036a\u03c2\5\u008aF\21\u036b\u036c\f\17")
        buf.write("\2\2\u036c\u036d\t\r\2\2\u036d\u03c2\5\u008aF\20\u036e")
        buf.write("\u036f\f\16\2\2\u036f\u0370\t\13\2\2\u0370\u03c2\5\u008a")
        buf.write("F\17\u0371\u0372\f\r\2\2\u0372\u0373\t\16\2\2\u0373\u03c2")
        buf.write("\5\u008aF\16\u0374\u0375\f\f\2\2\u0375\u0376\7N\2\2\u0376")
        buf.write("\u03c2\5\u008aF\r\u0377\u0378\f\13\2\2\u0378\u0379\7\5")
        buf.write("\2\2\u0379\u03c2\5\u008aF\f\u037a\u037b\f\n\2\2\u037b")
        buf.write("\u037c\7O\2\2\u037c\u03c2\5\u008aF\13\u037d\u037e\f\t")
        buf.write("\2\2\u037e\u037f\t\17\2\2\u037f\u03c2\5\u008aF\n\u0380")
        buf.write("\u0381\f\b\2\2\u0381\u0382\t\20\2\2\u0382\u03c2\5\u008a")
        buf.write("F\t\u0383\u0384\f\7\2\2\u0384\u0385\7R\2\2\u0385\u03c2")
        buf.write("\5\u008aF\b\u0386\u0387\f\6\2\2\u0387\u0388\7S\2\2\u0388")
        buf.write("\u03c2\5\u008aF\7\u0389\u038a\f\5\2\2\u038a\u038b\7T\2")
        buf.write("\2\u038b\u038c\5\u008aF\2\u038c\u038d\7\33\2\2\u038d\u038e")
        buf.write("\5\u008aF\6\u038e\u03c2\3\2\2\2\u038f\u0390\f\4\2\2\u0390")
        buf.write("\u0391\t\21\2\2\u0391\u03c2\5\u008aF\5\u0392\u0393\f ")
        buf.write("\2\2\u0393\u0395\7(\2\2\u0394\u0396\5\u008aF\2\u0395\u0394")
        buf.write("\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0397\3\2\2\2\u0397")
        buf.write("\u03c2\7)\2\2\u0398\u0399\f\36\2\2\u0399\u039b\7(\2\2")
        buf.write("\u039a\u039c\5\u008aF\2\u039b\u039a\3\2\2\2\u039b\u039c")
        buf.write("\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039f\7\33\2\2\u039e")
        buf.write("\u03a0\5\u008aF\2\u039f\u039e\3\2\2\2\u039f\u03a0\3\2")
        buf.write("\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03c2\7)\2\2\u03a2\u03a3")
        buf.write("\f\35\2\2\u03a3\u03a6\7+\2\2\u03a4\u03a7\5\u00c2b\2\u03a5")
        buf.write("\u03a7\7*\2\2\u03a6\u03a4\3\2\2\2\u03a6\u03a5\3\2\2\2")
        buf.write("\u03a7\u03c2\3\2\2\2\u03a8\u03a9\f\34\2\2\u03a9\u03b7")
        buf.write("\7\20\2\2\u03aa\u03ab\5\u00c2b\2\u03ab\u03ac\7\33\2\2")
        buf.write("\u03ac\u03b4\5\u008aF\2\u03ad\u03ae\7\21\2\2\u03ae\u03af")
        buf.write("\5\u00c2b\2\u03af\u03b0\7\33\2\2\u03b0\u03b1\5\u008aF")
        buf.write("\2\u03b1\u03b3\3\2\2\2\u03b2\u03ad\3\2\2\2\u03b3\u03b6")
        buf.write("\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5")
        buf.write("\u03b8\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03aa\3\2\2\2")
        buf.write("\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03c2\7")
        buf.write("\22\2\2\u03ba\u03bb\f\30\2\2\u03bb\u03c2\t\22\2\2\u03bc")
        buf.write("\u03bd\f\26\2\2\u03bd\u03be\7\30\2\2\u03be\u03bf\5\u0094")
        buf.write("K\2\u03bf\u03c0\7\31\2\2\u03c0\u03c2\3\2\2\2\u03c1\u0368")
        buf.write("\3\2\2\2\u03c1\u036b\3\2\2\2\u03c1\u036e\3\2\2\2\u03c1")
        buf.write("\u0371\3\2\2\2\u03c1\u0374\3\2\2\2\u03c1\u0377\3\2\2\2")
        buf.write("\u03c1\u037a\3\2\2\2\u03c1\u037d\3\2\2\2\u03c1\u0380\3")
        buf.write("\2\2\2\u03c1\u0383\3\2\2\2\u03c1\u0386\3\2\2\2\u03c1\u0389")
        buf.write("\3\2\2\2\u03c1\u038f\3\2\2\2\u03c1\u0392\3\2\2\2\u03c1")
        buf.write("\u0398\3\2\2\2\u03c1\u03a2\3\2\2\2\u03c1\u03a8\3\2\2\2")
        buf.write("\u03c1\u03ba\3\2\2\2\u03c1\u03bc\3\2\2\2\u03c2\u03c5\3")
        buf.write("\2\2\2\u03c3\u03c1\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4\u008b")
        buf.write("\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c6\u03d7\7n\2\2\u03c7")
        buf.write("\u03d7\5\u00c0a\2\u03c8\u03d7\7r\2\2\u03c9\u03d7\7\u0085")
        buf.write("\2\2\u03ca\u03cd\5\u00c2b\2\u03cb\u03cc\7(\2\2\u03cc\u03ce")
        buf.write("\7)\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce")
        buf.write("\u03d7\3\2\2\2\u03cf\u03d7\7\u0082\2\2\u03d0\u03d7\5\u00bc")
        buf.write("_\2\u03d1\u03d4\5\u00be`\2\u03d2\u03d3\7(\2\2\u03d3\u03d5")
        buf.write("\7)\2\2\u03d4\u03d2\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5")
        buf.write("\u03d7\3\2\2\2\u03d6\u03c6\3\2\2\2\u03d6\u03c7\3\2\2\2")
        buf.write("\u03d6\u03c8\3\2\2\2\u03d6\u03c9\3\2\2\2\u03d6\u03ca\3")
        buf.write("\2\2\2\u03d6\u03cf\3\2\2\2\u03d6\u03d0\3\2\2\2\u03d6\u03d1")
        buf.write("\3\2\2\2\u03d7\u008d\3\2\2\2\u03d8\u03dd\5\u008aF\2\u03d9")
        buf.write("\u03da\7\21\2\2\u03da\u03dc\5\u008aF\2\u03db\u03d9\3\2")
        buf.write("\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de")
        buf.write("\3\2\2\2\u03de\u008f\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0")
        buf.write("\u03e5\5\u0092J\2\u03e1\u03e2\7\21\2\2\u03e2\u03e4\5\u0092")
        buf.write("J\2\u03e3\u03e1\3\2\2\2\u03e4\u03e7\3\2\2\2\u03e5\u03e3")
        buf.write("\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e9\3\2\2\2\u03e7")
        buf.write("\u03e5\3\2\2\2\u03e8\u03ea\7\21\2\2\u03e9\u03e8\3\2\2")
        buf.write("\2\u03e9\u03ea\3\2\2\2\u03ea\u0091\3\2\2\2\u03eb\u03ec")
        buf.write("\5\u00c2b\2\u03ec\u03ed\7\33\2\2\u03ed\u03ee\5\u008aF")
        buf.write("\2\u03ee\u0093\3\2\2\2\u03ef\u03f1\7\20\2\2\u03f0\u03f2")
        buf.write("\5\u0090I\2\u03f1\u03f0\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2")
        buf.write("\u03f3\3\2\2\2\u03f3\u03f8\7\22\2\2\u03f4\u03f6\5\u008e")
        buf.write("H\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f8")
        buf.write("\3\2\2\2\u03f7\u03ef\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f8")
        buf.write("\u0095\3\2\2\2\u03f9\u03fa\5\u008aF\2\u03fa\u03fb\7\30")
        buf.write("\2\2\u03fb\u03fc\5\u0094K\2\u03fc\u03fd\7\31\2\2\u03fd")
        buf.write("\u0097\3\2\2\2\u03fe\u0402\7\20\2\2\u03ff\u0401\5\u009a")
        buf.write("N\2\u0400\u03ff\3\2\2\2\u0401\u0404\3\2\2\2\u0402\u0400")
        buf.write("\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0405\3\2\2\2\u0404")
        buf.write("\u0402\3\2\2\2\u0405\u0406\7\22\2\2\u0406\u0099\3\2\2")
        buf.write("\2\u0407\u0419\5\u00c2b\2\u0408\u0419\5\u0098M\2\u0409")
        buf.write("\u0419\5\u009cO\2\u040a\u0419\5\u00a0Q\2\u040b\u0419\5")
        buf.write("\u00a2R\2\u040c\u0419\5\u00a8U\2\u040d\u0419\5\u00aaV")
        buf.write("\2\u040e\u0419\5\u00acW\2\u040f\u0419\5\u00b0Y\2\u0410")
        buf.write("\u0419\5\u00b4[\2\u0411\u0419\5\u00b6\\\2\u0412\u0419")
        buf.write("\7u\2\2\u0413\u0419\7z\2\2\u0414\u0419\5\u00ba^\2\u0415")
        buf.write("\u0419\5\u00c0a\2\u0416\u0419\7\u0085\2\2\u0417\u0419")
        buf.write("\7r\2\2\u0418\u0407\3\2\2\2\u0418\u0408\3\2\2\2\u0418")
        buf.write("\u0409\3\2\2\2\u0418\u040a\3\2\2\2\u0418\u040b\3\2\2\2")
        buf.write("\u0418\u040c\3\2\2\2\u0418\u040d\3\2\2\2\u0418\u040e\3")
        buf.write("\2\2\2\u0418\u040f\3\2\2\2\u0418\u0410\3\2\2\2\u0418\u0411")
        buf.write("\3\2\2\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418")
        buf.write("\u0414\3\2\2\2\u0418\u0415\3\2\2\2\u0418\u0416\3\2\2\2")
        buf.write("\u0418\u0417\3\2\2\2\u0419\u009b\3\2\2\2\u041a\u041d\5")
        buf.write("\u009eP\2\u041b\u041d\5\u00b8]\2\u041c\u041a\3\2\2\2\u041c")
        buf.write("\u041b\3\2\2\2\u041d\u009d\3\2\2\2\u041e\u0423\79\2\2")
        buf.write("\u041f\u0423\7*\2\2\u0420\u0423\7?\2\2\u0421\u0423\5\u00c2")
        buf.write("b\2\u0422\u041e\3\2\2\2\u0422\u041f\3\2\2\2\u0422\u0420")
        buf.write("\3\2\2\2\u0422\u0421\3\2\2\2\u0423\u0430\3\2\2\2\u0424")
        buf.write("\u0426\7\30\2\2\u0425\u0427\5\u009cO\2\u0426\u0425\3\2")
        buf.write("\2\2\u0426\u0427\3\2\2\2\u0427\u042c\3\2\2\2\u0428\u0429")
        buf.write("\7\21\2\2\u0429\u042b\5\u009cO\2\u042a\u0428\3\2\2\2\u042b")
        buf.write("\u042e\3\2\2\2\u042c\u042a\3\2\2\2\u042c\u042d\3\2\2\2")
        buf.write("\u042d\u042f\3\2\2\2\u042e\u042c\3\2\2\2\u042f\u0431\7")
        buf.write("\31\2\2\u0430\u0424\3\2\2\2\u0430\u0431\3\2\2\2\u0431")
        buf.write("\u009f\3\2\2\2\u0432\u0433\7`\2\2\u0433\u0436\5\u00a4")
        buf.write("S\2\u0434\u0435\7a\2\2\u0435\u0437\5\u009cO\2\u0436\u0434")
        buf.write("\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u00a1\3\2\2\2\u0438")
        buf.write("\u0439\5\u00a4S\2\u0439\u043a\7a\2\2\u043a\u043b\5\u009c")
        buf.write("O\2\u043b\u00a3\3\2\2\2\u043c\u0442\5\u00c2b\2\u043d\u043e")
        buf.write("\7\30\2\2\u043e\u043f\5\u00a6T\2\u043f\u0440\7\31\2\2")
        buf.write("\u0440\u0442\3\2\2\2\u0441\u043c\3\2\2\2\u0441\u043d\3")
        buf.write("\2\2\2\u0442\u00a5\3\2\2\2\u0443\u0448\5\u00c2b\2\u0444")
        buf.write("\u0445\7\21\2\2\u0445\u0447\5\u00c2b\2\u0446\u0444\3\2")
        buf.write("\2\2\u0447\u044a\3\2\2\2\u0448\u0446\3\2\2\2\u0448\u0449")
        buf.write("\3\2\2\2\u0449\u00a7\3\2\2\2\u044a\u0448\3\2\2\2\u044b")
        buf.write("\u044c\7b\2\2\u044c\u044d\5\u00c2b\2\u044d\u00a9\3\2\2")
        buf.write("\2\u044e\u044f\5\u00c2b\2\u044f\u0450\7\33\2\2\u0450\u00ab")
        buf.write("\3\2\2\2\u0451\u0452\7c\2\2\u0452\u0456\5\u009cO\2\u0453")
        buf.write("\u0455\5\u00aeX\2\u0454\u0453\3\2\2\2\u0455\u0458\3\2")
        buf.write("\2\2\u0456\u0454\3\2\2\2\u0456\u0457\3\2\2\2\u0457\u00ad")
        buf.write("\3\2\2\2\u0458\u0456\3\2\2\2\u0459\u045a\7d\2\2\u045a")
        buf.write("\u045b\5\u00b8]\2\u045b\u045c\5\u0098M\2\u045c\u0460\3")
        buf.write("\2\2\2\u045d\u045e\7e\2\2\u045e\u0460\5\u0098M\2\u045f")
        buf.write("\u0459\3\2\2\2\u045f\u045d\3\2\2\2\u0460\u00af\3\2\2\2")
        buf.write("\u0461\u0462\7\"\2\2\u0462\u0463\5\u00c2b\2\u0463\u0465")
        buf.write("\7\30\2\2\u0464\u0466\5\u00a6T\2\u0465\u0464\3\2\2\2\u0465")
        buf.write("\u0466\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0469\7\31\2")
        buf.write("\2\u0468\u046a\5\u00b2Z\2\u0469\u0468\3\2\2\2\u0469\u046a")
        buf.write("\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c\5\u0098M\2\u046c")
        buf.write("\u00b1\3\2\2\2\u046d\u046e\7f\2\2\u046e\u046f\5\u00a6")
        buf.write("T\2\u046f\u00b3\3\2\2\2\u0470\u0473\7\36\2\2\u0471\u0474")
        buf.write("\5\u0098M\2\u0472\u0474\5\u009cO\2\u0473\u0471\3\2\2\2")
        buf.write("\u0473\u0472\3\2\2\2\u0474\u0475\3\2\2\2\u0475\u0478\5")
        buf.write("\u009cO\2\u0476\u0479\5\u0098M\2\u0477\u0479\5\u009cO")
        buf.write("\2\u0478\u0476\3\2\2\2\u0478\u0477\3\2\2\2\u0479\u047a")
        buf.write("\3\2\2\2\u047a\u047b\5\u0098M\2\u047b\u00b5\3\2\2\2\u047c")
        buf.write("\u047d\7\64\2\2\u047d\u047e\5\u009cO\2\u047e\u047f\5\u0098")
        buf.write("M\2\u047f\u00b7\3\2\2\2\u0480\u0481\t\23\2\2\u0481\u00b9")
        buf.write("\3\2\2\2\u0482\u0483\7\67\2\2\u0483\u0484\5\u00c2b\2\u0484")
        buf.write("\u0485\5\u0098M\2\u0485\u00bb\3\2\2\2\u0486\u0488\7\30")
        buf.write("\2\2\u0487\u0489\5\u008aF\2\u0488\u0487\3\2\2\2\u0488")
        buf.write("\u0489\3\2\2\2\u0489\u0490\3\2\2\2\u048a\u048c\7\21\2")
        buf.write("\2\u048b\u048d\5\u008aF\2\u048c\u048b\3\2\2\2\u048c\u048d")
        buf.write("\3\2\2\2\u048d\u048f\3\2\2\2\u048e\u048a\3\2\2\2\u048f")
        buf.write("\u0492\3\2\2\2\u0490\u048e\3\2\2\2\u0490\u0491\3\2\2\2")
        buf.write("\u0491\u0493\3\2\2\2\u0492\u0490\3\2\2\2\u0493\u04a1\7")
        buf.write("\31\2\2\u0494\u049d\7(\2\2\u0495\u049a\5\u008aF\2\u0496")
        buf.write("\u0497\7\21\2\2\u0497\u0499\5\u008aF\2\u0498\u0496\3\2")
        buf.write("\2\2\u0499\u049c\3\2\2\2\u049a\u0498\3\2\2\2\u049a\u049b")
        buf.write("\3\2\2\2\u049b\u049e\3\2\2\2\u049c\u049a\3\2\2\2\u049d")
        buf.write("\u0495\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u049f\3\2\2\2")
        buf.write("\u049f\u04a1\7)\2\2\u04a0\u0486\3\2\2\2\u04a0\u0494\3")
        buf.write("\2\2\2\u04a1\u00bd\3\2\2\2\u04a2\u04a5\5\u0088E\2\u04a3")
        buf.write("\u04a5\5L\'\2\u04a4\u04a2\3\2\2\2\u04a4\u04a3\3\2\2\2")
        buf.write("\u04a5\u00bf\3\2\2\2\u04a6\u04a8\t\24\2\2\u04a7\u04a9")
        buf.write("\7q\2\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9")
        buf.write("\u00c1\3\2\2\2\u04aa\u04b4\t\25\2\2\u04ab\u04b0\7\u0084")
        buf.write("\2\2\u04ac\u04ad\7\17\2\2\u04ad\u04af\7\u0084\2\2\u04ae")
        buf.write("\u04ac\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2")
        buf.write("\u04b0\u04b1\3\2\2\2\u04b1\u04b4\3\2\2\2\u04b2\u04b0\3")
        buf.write("\2\2\2\u04b3\u04aa\3\2\2\2\u04b3\u04ab\3\2\2\2\u04b4\u00c3")
        buf.write("\3\2\2\2\u008d\u00c5\u00cf\u00d1\u00e1\u00e5\u00ea\u00f1")
        buf.write("\u00f7\u00fd\u0101\u010d\u0115\u011a\u011d\u0120\u0123")
        buf.write("\u012d\u0130\u0136\u013d\u0141\u0147\u0156\u015b\u015f")
        buf.write("\u0169\u016f\u0175\u017e\u018c\u018f\u019b\u01a2\u01a5")
        buf.write("\u01a8\u01ac\u01b1\u01b5\u01c6\u01c8\u01cc\u01d2\u01dc")
        buf.write("\u01e2\u01ed\u01f0\u01fa\u01fd\u0203\u0206\u020e\u0211")
        buf.write("\u0217\u021a\u0222\u0225\u022b\u022f\u023a\u023f\u0244")
        buf.write("\u024c\u0253\u025e\u0260\u0265\u026a\u026f\u0271\u0279")
        buf.write("\u0284\u0286\u029e\u02a7\u02ad\u02b2\u02b7\u02bb\u02c0")
        buf.write("\u02cc\u02dc\u02e2\u02e6\u02e9\u02f0\u0304\u0316\u031a")
        buf.write("\u0326\u032a\u032e\u0333\u0338\u033c\u0349\u0366\u0395")
        buf.write("\u039b\u039f\u03a6\u03b4\u03b7\u03c1\u03c3\u03cd\u03d4")
        buf.write("\u03d6\u03dd\u03e5\u03e9\u03f1\u03f5\u03f7\u0402\u0418")
        buf.write("\u041c\u0422\u0426\u042c\u0430\u0436\u0441\u0448\u0456")
        buf.write("\u045f\u0465\u0469\u0473\u0478\u0488\u048c\u0490\u049a")
        buf.write("\u049d\u04a0\u04a4\u04a8\u04b0\u04b3")
        return buf.getvalue()


class SolidityParser ( Parser ):

    grammarFileName = "Solidity.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'pragma'", "';'", "'^'", "'~'", "'>='", 
                     "'>'", "'<'", "'<='", "'='", "'as'", "'import'", "'*'", 
                     "'from'", "'{'", "','", "'}'", "'abstract'", "'contract'", 
                     "'interface'", "'library'", "'is'", "'('", "')'", "'({'", 
                     "':'", "'})'", "'using'", "'for'", "'struct'", "'constructor'", 
                     "'modifier'", "'function'", "'receive'", "'fallback'", 
                     "'returns'", "'event'", "'enum'", "'['", "']'", "'address'", 
                     "'.'", "'mapping'", "'=>'", "'memory'", "'storage'", 
                     "'calldata'", "'unchecked'", "'try'", "'catch'", "'if'", 
                     "'else'", "'while'", "'assembly'", "'do'", "'return'", 
                     "'throw'", "'emit'", "'var'", "'bool'", "'string'", 
                     "'byte'", "'++'", "'--'", "'!'", "'delete'", "'-'", 
                     "'new'", "'+'", "'after'", "'**'", "'/'", "'%'", "'<<'", 
                     "'>>'", "'>>>'", "'&'", "'|'", "'=='", "'!='", "'&&'", 
                     "'||'", "'?'", "'|='", "'^='", "'&='", "'<<='", "'>>='", 
                     "'>>>='", "'+='", "'-='", "'*='", "'/='", "'%='", "'let'", 
                     "':='", "'=:'", "'switch'", "'case'", "'default'", 
                     "'->'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'anonymous'", "'break'", "'constant'", 
                     "'override'", "'immutable'", "'virtual'", "'continue'", 
                     "'external'", "'indexed'", "'internal'", "'payable'", 
                     "'private'", "'public'", "'pure'", "'type'", "'view'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "LicenseIdentifier", "Int", "Uint", "Byte", 
                      "Fixed", "Ufixed", "VersionLiteral", "BooleanLiteral", 
                      "DecimalNumber", "HexNumber", "NumberUnit", "HexLiteral", 
                      "ReservedKeyword", "AnonymousKeyword", "BreakKeyword", 
                      "ConstantKeyword", "OverrideKeyword", "ImmutableKeyword", 
                      "VirtualKeyword", "ContinueKeyword", "ExternalKeyword", 
                      "IndexedKeyword", "InternalKeyword", "PayableKeyword", 
                      "PrivateKeyword", "PublicKeyword", "PureKeyword", 
                      "TypeKeyword", "ViewKeyword", "Identifier", "StringLiteral", 
                      "WS", "NatSpecSingleLine", "NatSpecMultiLine", "LINE_COMMENT", 
                      "COMMENT" ]

    RULE_sourceUnit = 0
    RULE_spdxLicenseIdentifier = 1
    RULE_pragmaDirective = 2
    RULE_pragmaName = 3
    RULE_pragmaValue = 4
    RULE_version = 5
    RULE_versionOperator = 6
    RULE_versionConstraint = 7
    RULE_importDeclaration = 8
    RULE_importDirective = 9
    RULE_natSpec = 10
    RULE_contractDefinition = 11
    RULE_inheritanceSpecifier = 12
    RULE_callArgumentList = 13
    RULE_contractPart = 14
    RULE_stateVariableDeclaration = 15
    RULE_usingForDeclaration = 16
    RULE_structDefinition = 17
    RULE_constructorDefinition = 18
    RULE_modifierDefinition = 19
    RULE_modifierInvocation = 20
    RULE_functionDefinition = 21
    RULE_returnParameters = 22
    RULE_overrideParameters = 23
    RULE_modifierList = 24
    RULE_eventDefinition = 25
    RULE_enumValue = 26
    RULE_enumDefinition = 27
    RULE_parameterList = 28
    RULE_objectList = 29
    RULE_parameter = 30
    RULE_eventParameterList = 31
    RULE_eventParameter = 32
    RULE_functionTypeParameterList = 33
    RULE_functionTypeParameter = 34
    RULE_variableDeclaration = 35
    RULE_typeName = 36
    RULE_userDefinedTypeName = 37
    RULE_mapping = 38
    RULE_functionTypeName = 39
    RULE_visibility = 40
    RULE_storageLocation = 41
    RULE_stateMutability = 42
    RULE_block = 43
    RULE_uncheckedBlock = 44
    RULE_statement = 45
    RULE_tryStatement = 46
    RULE_catchClause = 47
    RULE_expressionStatement = 48
    RULE_ifStatement = 49
    RULE_ifCondition = 50
    RULE_ifRight = 51
    RULE_ifWrong = 52
    RULE_whileStatement = 53
    RULE_simpleStatement = 54
    RULE_forStatement = 55
    RULE_inlineAssemblyStatement = 56
    RULE_doWhileStatement = 57
    RULE_continueStatement = 58
    RULE_breakStatement = 59
    RULE_returnStatement = 60
    RULE_throwStatement = 61
    RULE_emitStatement = 62
    RULE_variableDeclarationStatement = 63
    RULE_constantVariableDeclaration = 64
    RULE_variableDeclarationList = 65
    RULE_identifierList = 66
    RULE_elementaryTypeName = 67
    RULE_expression = 68
    RULE_primaryExpression = 69
    RULE_expressionList = 70
    RULE_nameValueList = 71
    RULE_nameValue = 72
    RULE_functionCallArguments = 73
    RULE_functionCall = 74
    RULE_assemblyBlock = 75
    RULE_assemblyItem = 76
    RULE_assemblyExpression = 77
    RULE_assemblyCall = 78
    RULE_assemblyLocalDefinition = 79
    RULE_assemblyAssignment = 80
    RULE_assemblyIdentifierOrList = 81
    RULE_assemblyIdentifierList = 82
    RULE_assemblyStackAssignment = 83
    RULE_labelDefinition = 84
    RULE_assemblySwitch = 85
    RULE_assemblyCase = 86
    RULE_assemblyFunctionDefinition = 87
    RULE_assemblyFunctionReturns = 88
    RULE_assemblyFor = 89
    RULE_assemblyIf = 90
    RULE_assemblyLiteral = 91
    RULE_subAssembly = 92
    RULE_tupleExpression = 93
    RULE_typeNameExpression = 94
    RULE_numberLiteral = 95
    RULE_identifier = 96

    ruleNames =  [ "sourceUnit", "spdxLicenseIdentifier", "pragmaDirective", 
                   "pragmaName", "pragmaValue", "version", "versionOperator", 
                   "versionConstraint", "importDeclaration", "importDirective", 
                   "natSpec", "contractDefinition", "inheritanceSpecifier", 
                   "callArgumentList", "contractPart", "stateVariableDeclaration", 
                   "usingForDeclaration", "structDefinition", "constructorDefinition", 
                   "modifierDefinition", "modifierInvocation", "functionDefinition", 
                   "returnParameters", "overrideParameters", "modifierList", 
                   "eventDefinition", "enumValue", "enumDefinition", "parameterList", 
                   "objectList", "parameter", "eventParameterList", "eventParameter", 
                   "functionTypeParameterList", "functionTypeParameter", 
                   "variableDeclaration", "typeName", "userDefinedTypeName", 
                   "mapping", "functionTypeName", "visibility", "storageLocation", 
                   "stateMutability", "block", "uncheckedBlock", "statement", 
                   "tryStatement", "catchClause", "expressionStatement", 
                   "ifStatement", "ifCondition", "ifRight", "ifWrong", "whileStatement", 
                   "simpleStatement", "forStatement", "inlineAssemblyStatement", 
                   "doWhileStatement", "continueStatement", "breakStatement", 
                   "returnStatement", "throwStatement", "emitStatement", 
                   "variableDeclarationStatement", "constantVariableDeclaration", 
                   "variableDeclarationList", "identifierList", "elementaryTypeName", 
                   "expression", "primaryExpression", "expressionList", 
                   "nameValueList", "nameValue", "functionCallArguments", 
                   "functionCall", "assemblyBlock", "assemblyItem", "assemblyExpression", 
                   "assemblyCall", "assemblyLocalDefinition", "assemblyAssignment", 
                   "assemblyIdentifierOrList", "assemblyIdentifierList", 
                   "assemblyStackAssignment", "labelDefinition", "assemblySwitch", 
                   "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", 
                   "assemblyFor", "assemblyIf", "assemblyLiteral", "subAssembly", 
                   "tupleExpression", "typeNameExpression", "numberLiteral", 
                   "identifier" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    T__51=52
    T__52=53
    T__53=54
    T__54=55
    T__55=56
    T__56=57
    T__57=58
    T__58=59
    T__59=60
    T__60=61
    T__61=62
    T__62=63
    T__63=64
    T__64=65
    T__65=66
    T__66=67
    T__67=68
    T__68=69
    T__69=70
    T__70=71
    T__71=72
    T__72=73
    T__73=74
    T__74=75
    T__75=76
    T__76=77
    T__77=78
    T__78=79
    T__79=80
    T__80=81
    T__81=82
    T__82=83
    T__83=84
    T__84=85
    T__85=86
    T__86=87
    T__87=88
    T__88=89
    T__89=90
    T__90=91
    T__91=92
    T__92=93
    T__93=94
    T__94=95
    T__95=96
    T__96=97
    T__97=98
    T__98=99
    T__99=100
    LicenseIdentifier=101
    Int=102
    Uint=103
    Byte=104
    Fixed=105
    Ufixed=106
    VersionLiteral=107
    BooleanLiteral=108
    DecimalNumber=109
    HexNumber=110
    NumberUnit=111
    HexLiteral=112
    ReservedKeyword=113
    AnonymousKeyword=114
    BreakKeyword=115
    ConstantKeyword=116
    OverrideKeyword=117
    ImmutableKeyword=118
    VirtualKeyword=119
    ContinueKeyword=120
    ExternalKeyword=121
    IndexedKeyword=122
    InternalKeyword=123
    PayableKeyword=124
    PrivateKeyword=125
    PublicKeyword=126
    PureKeyword=127
    TypeKeyword=128
    ViewKeyword=129
    Identifier=130
    StringLiteral=131
    WS=132
    NatSpecSingleLine=133
    NatSpecMultiLine=134
    LINE_COMMENT=135
    COMMENT=136

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




    class SourceUnitContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def spdxLicenseIdentifier(self):
            return self.getTypedRuleContext(SolidityParser.SpdxLicenseIdentifierContext,0)


        def natSpec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.NatSpecContext)
            else:
                return self.getTypedRuleContext(SolidityParser.NatSpecContext,i)


        def pragmaDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i)


        def importDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i)


        def contractDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i)


        def functionDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,i)


        def constantVariableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ConstantVariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ConstantVariableDeclarationContext,i)


        def structDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StructDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,i)


        def enumDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_sourceUnit

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSourceUnit" ):
                return visitor.visitSourceUnit(self)
            else:
                return visitor.visitChildren(self)




    def sourceUnit(self):

        localctx = SolidityParser.SourceUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_sourceUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.LicenseIdentifier:
                self.state = 194
                self.spdxLicenseIdentifier()


            self.state = 207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__0) | (1 << SolidityParser.T__10) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__16) | (1 << SolidityParser.T__17) | (1 << SolidityParser.T__18) | (1 << SolidityParser.T__19) | (1 << SolidityParser.T__28) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__36) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)) | (1 << (SolidityParser.NatSpecSingleLine - 102)) | (1 << (SolidityParser.NatSpecMultiLine - 102)))) != 0):
                self.state = 205
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                if la_ == 1:
                    self.state = 197
                    self.natSpec()
                    pass

                elif la_ == 2:
                    self.state = 198
                    self.pragmaDirective()
                    pass

                elif la_ == 3:
                    self.state = 199
                    self.importDirective()
                    pass

                elif la_ == 4:
                    self.state = 200
                    self.contractDefinition()
                    pass

                elif la_ == 5:
                    self.state = 201
                    self.functionDefinition()
                    pass

                elif la_ == 6:
                    self.state = 202
                    self.constantVariableDeclaration()
                    pass

                elif la_ == 7:
                    self.state = 203
                    self.structDefinition()
                    pass

                elif la_ == 8:
                    self.state = 204
                    self.enumDefinition()
                    pass


                self.state = 209
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 210
            self.match(SolidityParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SpdxLicenseIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LicenseIdentifier(self):
            return self.getToken(SolidityParser.LicenseIdentifier, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_spdxLicenseIdentifier

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSpdxLicenseIdentifier" ):
                return visitor.visitSpdxLicenseIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def spdxLicenseIdentifier(self):

        localctx = SolidityParser.SpdxLicenseIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_spdxLicenseIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 212
            self.match(SolidityParser.LicenseIdentifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pragmaName(self):
            return self.getTypedRuleContext(SolidityParser.PragmaNameContext,0)


        def pragmaValue(self):
            return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaDirective

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaDirective" ):
                return visitor.visitPragmaDirective(self)
            else:
                return visitor.visitChildren(self)




    def pragmaDirective(self):

        localctx = SolidityParser.PragmaDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_pragmaDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 214
            self.match(SolidityParser.T__0)
            self.state = 215
            self.pragmaName()
            self.state = 216
            self.pragmaValue()
            self.state = 217
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaNameContext(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(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaName

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaName" ):
                return visitor.visitPragmaName(self)
            else:
                return visitor.visitChildren(self)




    def pragmaName(self):

        localctx = SolidityParser.PragmaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_pragmaName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def version(self):
            return self.getTypedRuleContext(SolidityParser.VersionContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaValue

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPragmaValue" ):
                return visitor.visitPragmaValue(self)
            else:
                return visitor.visitChildren(self)




    def pragmaValue(self):

        localctx = SolidityParser.PragmaValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_pragmaValue)
        try:
            self.state = 223
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 221
                self.version()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 222
                self.expression(0)
                pass


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


    class VersionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def versionConstraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_version

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersion" ):
                return visitor.visitVersion(self)
            else:
                return visitor.visitChildren(self)




    def version(self):

        localctx = SolidityParser.VersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_version)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self.versionConstraint()
            self.state = 227
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0) or _la==SolidityParser.VersionLiteral:
                self.state = 226
                self.versionConstraint()


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


    class VersionOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_versionOperator

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionOperator" ):
                return visitor.visitVersionOperator(self)
            else:
                return visitor.visitChildren(self)




    def versionOperator(self):

        localctx = SolidityParser.VersionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_versionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 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 VersionConstraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VersionLiteral(self):
            return self.getToken(SolidityParser.VersionLiteral, 0)

        def versionOperator(self):
            return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_versionConstraint

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVersionConstraint" ):
                return visitor.visitVersionConstraint(self)
            else:
                return visitor.visitChildren(self)




    def versionConstraint(self):

        localctx = SolidityParser.VersionConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_versionConstraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__2) | (1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8))) != 0):
                self.state = 231
                self.versionOperator()


            self.state = 234
            self.match(SolidityParser.VersionLiteral)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDeclaration

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDeclaration" ):
                return visitor.visitImportDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def importDeclaration(self):

        localctx = SolidityParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_importDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 236
            self.identifier()
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__9:
                self.state = 237
                self.match(SolidityParser.T__9)
                self.state = 238
                self.identifier()


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


    class ImportDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def importDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDirective

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportDirective" ):
                return visitor.visitImportDirective(self)
            else:
                return visitor.visitChildren(self)




    def importDirective(self):

        localctx = SolidityParser.ImportDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_importDirective)
        self._la = 0 # Token type
        try:
            self.state = 275
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 241
                self.match(SolidityParser.T__10)
                self.state = 242
                self.match(SolidityParser.StringLiteral)
                self.state = 245
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__9:
                    self.state = 243
                    self.match(SolidityParser.T__9)
                    self.state = 244
                    self.identifier()


                self.state = 247
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 248
                self.match(SolidityParser.T__10)
                self.state = 251
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__11]:
                    self.state = 249
                    self.match(SolidityParser.T__11)
                    pass
                elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                    self.state = 250
                    self.identifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__9:
                    self.state = 253
                    self.match(SolidityParser.T__9)
                    self.state = 254
                    self.identifier()


                self.state = 257
                self.match(SolidityParser.T__12)
                self.state = 258
                self.match(SolidityParser.StringLiteral)
                self.state = 259
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 260
                self.match(SolidityParser.T__10)
                self.state = 261
                self.match(SolidityParser.T__13)
                self.state = 262
                self.importDeclaration()
                self.state = 267
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 263
                    self.match(SolidityParser.T__14)
                    self.state = 264
                    self.importDeclaration()
                    self.state = 269
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 270
                self.match(SolidityParser.T__15)
                self.state = 271
                self.match(SolidityParser.T__12)
                self.state = 272
                self.match(SolidityParser.StringLiteral)
                self.state = 273
                self.match(SolidityParser.T__1)
                pass


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


    class NatSpecContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def NatSpecMultiLine(self):
            return self.getToken(SolidityParser.NatSpecMultiLine, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_natSpec

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNatSpec" ):
                return visitor.visitNatSpec(self)
            else:
                return visitor.visitChildren(self)




    def natSpec(self):

        localctx = SolidityParser.NatSpecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_natSpec)
        try:
            self.state = 283
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.NatSpecSingleLine]:
                self.enterOuterAlt(localctx, 1)
                self.state = 278 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 277
                        self.match(SolidityParser.NatSpecSingleLine)

                    else:
                        raise NoViableAltException(self)
                    self.state = 280 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

                pass
            elif token in [SolidityParser.NatSpecMultiLine]:
                self.enterOuterAlt(localctx, 2)
                self.state = 282
                self.match(SolidityParser.NatSpecMultiLine)
                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 ContractDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def natSpec(self):
            return self.getTypedRuleContext(SolidityParser.NatSpecContext,0)


        def inheritanceSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i)


        def contractPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractPartContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractPartContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractDefinition" ):
                return visitor.visitContractDefinition(self)
            else:
                return visitor.visitChildren(self)




    def contractDefinition(self):

        localctx = SolidityParser.ContractDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_contractDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine:
                self.state = 285
                self.natSpec()


            self.state = 289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__16:
                self.state = 288
                self.match(SolidityParser.T__16)


            self.state = 291
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__17) | (1 << SolidityParser.T__18) | (1 << SolidityParser.T__19))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 292
            self.identifier()
            self.state = 302
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__20:
                self.state = 293
                self.match(SolidityParser.T__20)
                self.state = 294
                self.inheritanceSpecifier()
                self.state = 299
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 295
                    self.match(SolidityParser.T__14)
                    self.state = 296
                    self.inheritanceSpecifier()
                    self.state = 301
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 304
            self.match(SolidityParser.T__13)
            self.state = 308
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__26) | (1 << SolidityParser.T__28) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__30) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__36) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)) | (1 << (SolidityParser.NatSpecSingleLine - 102)) | (1 << (SolidityParser.NatSpecMultiLine - 102)))) != 0):
                self.state = 305
                self.contractPart()
                self.state = 310
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 311
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritanceSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def callArgumentList(self):
            return self.getTypedRuleContext(SolidityParser.CallArgumentListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inheritanceSpecifier

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInheritanceSpecifier" ):
                return visitor.visitInheritanceSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def inheritanceSpecifier(self):

        localctx = SolidityParser.InheritanceSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_inheritanceSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 313
            self.userDefinedTypeName()
            self.state = 315
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__21 or _la==SolidityParser.T__23:
                self.state = 314
                self.callArgumentList()


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


    class CallArgumentListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_callArgumentList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCallArgumentList" ):
                return visitor.visitCallArgumentList(self)
            else:
                return visitor.visitChildren(self)




    def callArgumentList(self):

        localctx = SolidityParser.CallArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_callArgumentList)
        self._la = 0 # Token type
        try:
            self.state = 349
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__21]:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.match(SolidityParser.T__21)
                self.state = 319
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                    self.state = 318
                    self.expression(0)


                self.state = 325
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 321
                    self.match(SolidityParser.T__14)
                    self.state = 322
                    self.expression(0)
                    self.state = 327
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 328
                self.match(SolidityParser.T__22)
                pass
            elif token in [SolidityParser.T__23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 329
                self.match(SolidityParser.T__23)
                self.state = 345
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                    self.state = 330
                    self.identifier()
                    self.state = 331
                    self.match(SolidityParser.T__24)
                    self.state = 332
                    self.expression(0)
                    self.state = 340
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SolidityParser.T__14:
                        self.state = 333
                        self.match(SolidityParser.T__14)
                        self.state = 334
                        self.identifier()
                        self.state = 335
                        self.match(SolidityParser.T__24)
                        self.state = 336
                        self.expression(0)
                        self.state = 342
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 347
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 348
                self.match(SolidityParser.T__25)
                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 ContractPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stateVariableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.StateVariableDeclarationContext,0)


        def usingForDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0)


        def structDefinition(self):
            return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0)


        def constructorDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ConstructorDefinitionContext,0)


        def modifierDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,0)


        def eventDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0)


        def enumDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractPart

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContractPart" ):
                return visitor.visitContractPart(self)
            else:
                return visitor.visitChildren(self)




    def contractPart(self):

        localctx = SolidityParser.ContractPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_contractPart)
        try:
            self.state = 359
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 351
                self.stateVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 352
                self.usingForDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 353
                self.structDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 354
                self.constructorDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 355
                self.modifierDefinition()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 356
                self.functionDefinition()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 357
                self.eventDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 358
                self.enumDefinition()
                pass


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


    class StateVariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


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


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


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

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

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

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

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

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

        def getRuleIndex(self):
            return SolidityParser.RULE_stateVariableDeclaration

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateVariableDeclaration" ):
                return visitor.visitStateVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def stateVariableDeclaration(self):

        localctx = SolidityParser.StateVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_stateVariableDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.typeName(0)
            self.state = 365
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.ImmutableKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)))) != 0):
                self.state = 362
                _la = self._input.LA(1)
                if not(((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.ImmutableKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 367
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 368
            self.identifier()
            self.state = 371
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__8:
                self.state = 369
                self.match(SolidityParser.T__8)
                self.state = 370
                self.expression(0)


            self.state = 373
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForDeclarationContext(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(SolidityParser.IdentifierContext,0)


        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_usingForDeclaration

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingForDeclaration" ):
                return visitor.visitUsingForDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def usingForDeclaration(self):

        localctx = SolidityParser.UsingForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_usingForDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 375
            self.match(SolidityParser.T__26)
            self.state = 376
            self.identifier()
            self.state = 377
            self.match(SolidityParser.T__27)
            self.state = 380
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__11]:
                self.state = 378
                self.match(SolidityParser.T__11)
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__31, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.Identifier]:
                self.state = 379
                self.typeName(0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 382
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StructDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_structDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStructDefinition" ):
                return visitor.visitStructDefinition(self)
            else:
                return visitor.visitChildren(self)




    def structDefinition(self):

        localctx = SolidityParser.StructDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_structDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            self.match(SolidityParser.T__28)
            self.state = 385
            self.identifier()
            self.state = 386
            self.match(SolidityParser.T__13)
            self.state = 397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 387
                self.variableDeclaration()
                self.state = 388
                self.match(SolidityParser.T__1)
                self.state = 394
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                    self.state = 389
                    self.variableDeclaration()
                    self.state = 390
                    self.match(SolidityParser.T__1)
                    self.state = 396
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 399
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_constructorDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstructorDefinition" ):
                return visitor.visitConstructorDefinition(self)
            else:
                return visitor.visitChildren(self)




    def constructorDefinition(self):

        localctx = SolidityParser.ConstructorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_constructorDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self.match(SolidityParser.T__29)
            self.state = 402
            self.parameterList()
            self.state = 403
            self.modifierList()
            self.state = 404
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierDefinition" ):
                return visitor.visitModifierDefinition(self)
            else:
                return visitor.visitChildren(self)




    def modifierDefinition(self):

        localctx = SolidityParser.ModifierDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_modifierDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 406
            self.match(SolidityParser.T__30)
            self.state = 407
            self.identifier()
            self.state = 409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__21:
                self.state = 408
                self.parameterList()


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


    class ModifierInvocationContext(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(SolidityParser.IdentifierContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierInvocation

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierInvocation" ):
                return visitor.visitModifierInvocation(self)
            else:
                return visitor.visitChildren(self)




    def modifierInvocation(self):

        localctx = SolidityParser.ModifierInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_modifierInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            self.identifier()
            self.state = 419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__21:
                self.state = 414
                self.match(SolidityParser.T__21)
                self.state = 416
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                    self.state = 415
                    self.expressionList()


                self.state = 418
                self.match(SolidityParser.T__22)


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


    class FunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def natSpec(self):
            return self.getTypedRuleContext(SolidityParser.NatSpecContext,0)


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


        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDefinition" ):
                return visitor.visitFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def functionDefinition(self):

        localctx = SolidityParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine:
                self.state = 421
                self.natSpec()


            self.state = 424
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__33))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 426
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 425
                self.identifier()


            self.state = 428
            self.parameterList()
            self.state = 429
            self.modifierList()
            self.state = 431
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__34:
                self.state = 430
                self.returnParameters()


            self.state = 435
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__1]:
                self.state = 433
                self.match(SolidityParser.T__1)
                pass
            elif token in [SolidityParser.T__13]:
                self.state = 434
                self.block()
                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 ReturnParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnParameters

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnParameters" ):
                return visitor.visitReturnParameters(self)
            else:
                return visitor.visitChildren(self)




    def returnParameters(self):

        localctx = SolidityParser.ReturnParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_returnParameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            self.match(SolidityParser.T__34)
            self.state = 438
            self.parameterList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OverrideParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OverrideKeyword(self):
            return self.getToken(SolidityParser.OverrideKeyword, 0)

        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_overrideParameters

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOverrideParameters" ):
                return visitor.visitOverrideParameters(self)
            else:
                return visitor.visitChildren(self)




    def overrideParameters(self):

        localctx = SolidityParser.OverrideParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_overrideParameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440
            self.match(SolidityParser.OverrideKeyword)
            self.state = 441
            self.parameterList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def modifierInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i)


        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


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

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

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

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

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

        def overrideParameters(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideParametersContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideParametersContext,i)


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

        def getRuleIndex(self):
            return SolidityParser.RULE_modifierList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModifierList" ):
                return visitor.visitModifierList(self)
            else:
                return visitor.visitChildren(self)




    def modifierList(self):

        localctx = SolidityParser.ModifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_modifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.OverrideKeyword - 116)) | (1 << (SolidityParser.VirtualKeyword - 116)) | (1 << (SolidityParser.ExternalKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)) | (1 << (SolidityParser.Identifier - 116)))) != 0):
                self.state = 452
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                if la_ == 1:
                    self.state = 443
                    self.modifierInvocation()
                    pass

                elif la_ == 2:
                    self.state = 444
                    self.stateMutability()
                    pass

                elif la_ == 3:
                    self.state = 445
                    self.match(SolidityParser.ExternalKeyword)
                    pass

                elif la_ == 4:
                    self.state = 446
                    self.match(SolidityParser.PublicKeyword)
                    pass

                elif la_ == 5:
                    self.state = 447
                    self.match(SolidityParser.InternalKeyword)
                    pass

                elif la_ == 6:
                    self.state = 448
                    self.match(SolidityParser.PrivateKeyword)
                    pass

                elif la_ == 7:
                    self.state = 449
                    self.match(SolidityParser.OverrideKeyword)
                    pass

                elif la_ == 8:
                    self.state = 450
                    self.overrideParameters()
                    pass

                elif la_ == 9:
                    self.state = 451
                    self.match(SolidityParser.VirtualKeyword)
                    pass


                self.state = 456
                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 EventDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def eventParameterList(self):
            return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0)


        def natSpec(self):
            return self.getTypedRuleContext(SolidityParser.NatSpecContext,0)


        def AnonymousKeyword(self):
            return self.getToken(SolidityParser.AnonymousKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_eventDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventDefinition" ):
                return visitor.visitEventDefinition(self)
            else:
                return visitor.visitChildren(self)




    def eventDefinition(self):

        localctx = SolidityParser.EventDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_eventDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine:
                self.state = 457
                self.natSpec()


            self.state = 460
            self.match(SolidityParser.T__35)
            self.state = 461
            self.identifier()
            self.state = 462
            self.eventParameterList()
            self.state = 464
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.AnonymousKeyword:
                self.state = 463
                self.match(SolidityParser.AnonymousKeyword)


            self.state = 466
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueContext(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(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumValue

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValue" ):
                return visitor.visitEnumValue(self)
            else:
                return visitor.visitChildren(self)




    def enumValue(self):

        localctx = SolidityParser.EnumValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_enumValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 468
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def enumValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumDefinition" ):
                return visitor.visitEnumDefinition(self)
            else:
                return visitor.visitChildren(self)




    def enumDefinition(self):

        localctx = SolidityParser.EnumDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_enumDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 470
            self.match(SolidityParser.T__36)
            self.state = 471
            self.identifier()
            self.state = 472
            self.match(SolidityParser.T__13)
            self.state = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 473
                self.enumValue()


            self.state = 480
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 476
                self.match(SolidityParser.T__14)
                self.state = 477
                self.enumValue()
                self.state = 482
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 483
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameterList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterList" ):
                return visitor.visitParameterList(self)
            else:
                return visitor.visitChildren(self)




    def parameterList(self):

        localctx = SolidityParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 485
            self.match(SolidityParser.T__21)
            self.state = 494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 486
                self.parameter()
                self.state = 491
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 487
                    self.match(SolidityParser.T__14)
                    self.state = 488
                    self.parameter()
                    self.state = 493
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 496
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_objectList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectList" ):
                return visitor.visitObjectList(self)
            else:
                return visitor.visitChildren(self)




    def objectList(self):

        localctx = SolidityParser.ObjectListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_objectList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.match(SolidityParser.T__21)
            self.state = 507
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 499
                self.parameter()
                self.state = 504
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 500
                    self.match(SolidityParser.T__14)
                    self.state = 501
                    self.parameter()
                    self.state = 506
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 509
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_parameter

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameter" ):
                return visitor.visitParameter(self)
            else:
                return visitor.visitChildren(self)




    def parameter(self):

        localctx = SolidityParser.ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            self.typeName(0)
            self.state = 513
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.state = 512
                self.storageLocation()


            self.state = 516
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 515
                self.identifier()


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


    class EventParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def eventParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EventParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EventParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameterList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameterList" ):
                return visitor.visitEventParameterList(self)
            else:
                return visitor.visitChildren(self)




    def eventParameterList(self):

        localctx = SolidityParser.EventParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_eventParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 518
            self.match(SolidityParser.T__21)
            self.state = 527
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 519
                self.eventParameter()
                self.state = 524
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 520
                    self.match(SolidityParser.T__14)
                    self.state = 521
                    self.eventParameter()
                    self.state = 526
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 529
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def IndexedKeyword(self):
            return self.getToken(SolidityParser.IndexedKeyword, 0)

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


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameter

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEventParameter" ):
                return visitor.visitEventParameter(self)
            else:
                return visitor.visitChildren(self)




    def eventParameter(self):

        localctx = SolidityParser.EventParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_eventParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self.typeName(0)
            self.state = 533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.IndexedKeyword:
                self.state = 532
                self.match(SolidityParser.IndexedKeyword)


            self.state = 536
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 535
                self.identifier()


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


    class FunctionTypeParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionTypeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameterList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameterList" ):
                return visitor.visitFunctionTypeParameterList(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameterList(self):

        localctx = SolidityParser.FunctionTypeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_functionTypeParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.match(SolidityParser.T__21)
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 539
                self.functionTypeParameter()
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 540
                    self.match(SolidityParser.T__14)
                    self.state = 541
                    self.functionTypeParameter()
                    self.state = 546
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 549
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameter

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeParameter" ):
                return visitor.visitFunctionTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeParameter(self):

        localctx = SolidityParser.FunctionTypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_functionTypeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.typeName(0)
            self.state = 553
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__43) | (1 << SolidityParser.T__44) | (1 << SolidityParser.T__45))) != 0):
                self.state = 552
                self.storageLocation()


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


    class VariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


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


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclaration

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclaration" ):
                return visitor.visitVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclaration(self):

        localctx = SolidityParser.VariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_variableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 555
            self.typeName(0)
            self.state = 557
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 556
                self.storageLocation()


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


    class TypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def mapping(self):
            return self.getTypedRuleContext(SolidityParser.MappingContext,0)


        def functionTypeName(self):
            return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0)


        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_typeName

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeName" ):
                return visitor.visitTypeName(self)
            else:
                return visitor.visitChildren(self)



    def typeName(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 72
        self.enterRecursionRule(localctx, 72, self.RULE_typeName, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                self.state = 562
                self.elementaryTypeName()
                pass

            elif la_ == 2:
                self.state = 563
                self.userDefinedTypeName()
                pass

            elif la_ == 3:
                self.state = 564
                self.mapping()
                pass

            elif la_ == 4:
                self.state = 565
                self.functionTypeName()
                pass

            elif la_ == 5:
                self.state = 566
                self.match(SolidityParser.T__39)
                self.state = 567
                self.match(SolidityParser.PayableKeyword)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 578
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SolidityParser.TypeNameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeName)
                    self.state = 570
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 571
                    self.match(SolidityParser.T__37)
                    self.state = 573
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                        self.state = 572
                        self.expression(0)


                    self.state = 575
                    self.match(SolidityParser.T__38) 
                self.state = 580
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,60,self._ctx)

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


    class UserDefinedTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_userDefinedTypeName

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUserDefinedTypeName" ):
                return visitor.visitUserDefinedTypeName(self)
            else:
                return visitor.visitChildren(self)




    def userDefinedTypeName(self):

        localctx = SolidityParser.UserDefinedTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_userDefinedTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 581
            self.identifier()
            self.state = 586
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 582
                    self.match(SolidityParser.T__40)
                    self.state = 583
                    self.identifier() 
                self.state = 588
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

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


    class MappingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mapping

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMapping" ):
                return visitor.visitMapping(self)
            else:
                return visitor.visitChildren(self)




    def mapping(self):

        localctx = SolidityParser.MappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_mapping)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 589
            self.match(SolidityParser.T__41)
            self.state = 590
            self.match(SolidityParser.T__21)
            self.state = 593
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__39, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]:
                self.state = 591
                self.elementaryTypeName()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                self.state = 592
                self.userDefinedTypeName()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 595
            self.match(SolidityParser.T__42)
            self.state = 596
            self.typeName(0)
            self.state = 597
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionTypeParameterList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i)


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

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

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def parameterList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterListContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterListContext,i)


        def visibility(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VisibilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VisibilityContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeName

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTypeName" ):
                return visitor.visitFunctionTypeName(self)
            else:
                return visitor.visitChildren(self)




    def functionTypeName(self):

        localctx = SolidityParser.FunctionTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_functionTypeName)
        self._la = 0 # Token type
        try:
            self.state = 631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 599
                self.match(SolidityParser.T__31)
                self.state = 600
                self.functionTypeParameterList()
                self.state = 606
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,64,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 604
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [SolidityParser.InternalKeyword]:
                            self.state = 601
                            self.match(SolidityParser.InternalKeyword)
                            pass
                        elif token in [SolidityParser.ExternalKeyword]:
                            self.state = 602
                            self.match(SolidityParser.ExternalKeyword)
                            pass
                        elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]:
                            self.state = 603
                            self.stateMutability()
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 608
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,64,self._ctx)

                self.state = 611
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
                if la_ == 1:
                    self.state = 609
                    self.match(SolidityParser.T__34)
                    self.state = 610
                    self.functionTypeParameterList()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 613
                self.match(SolidityParser.T__31)
                self.state = 614
                self.match(SolidityParser.T__21)
                self.state = 616
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__21:
                    self.state = 615
                    self.parameterList()


                self.state = 618
                self.match(SolidityParser.T__22)
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.ExternalKeyword - 116)) | (1 << (SolidityParser.InternalKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PrivateKeyword - 116)) | (1 << (SolidityParser.PublicKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)))) != 0):
                    self.state = 621
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SolidityParser.ExternalKeyword, SolidityParser.InternalKeyword, SolidityParser.PrivateKeyword, SolidityParser.PublicKeyword]:
                        self.state = 619
                        self.visibility()
                        pass
                    elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]:
                        self.state = 620
                        self.stateMutability()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 625
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 626
                self.match(SolidityParser.T__34)
                self.state = 627
                self.match(SolidityParser.T__21)
                self.state = 628
                self.parameterList()
                self.state = 629
                self.match(SolidityParser.T__22)
                pass


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


    class VisibilityContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def InternalKeyword(self):
            return self.getToken(SolidityParser.InternalKeyword, 0)

        def ExternalKeyword(self):
            return self.getToken(SolidityParser.ExternalKeyword, 0)

        def PrivateKeyword(self):
            return self.getToken(SolidityParser.PrivateKeyword, 0)

        def PublicKeyword(self):
            return self.getToken(SolidityParser.PublicKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_visibility

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVisibility" ):
                return visitor.visitVisibility(self)
            else:
                return visitor.visitChildren(self)




    def visibility(self):

        localctx = SolidityParser.VisibilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 633
            _la = self._input.LA(1)
            if not(((((_la - 121)) & ~0x3f) == 0 and ((1 << (_la - 121)) & ((1 << (SolidityParser.ExternalKeyword - 121)) | (1 << (SolidityParser.InternalKeyword - 121)) | (1 << (SolidityParser.PrivateKeyword - 121)) | (1 << (SolidityParser.PublicKeyword - 121)))) != 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 StorageLocationContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_storageLocation

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageLocation" ):
                return visitor.visitStorageLocation(self)
            else:
                return visitor.visitChildren(self)




    def storageLocation(self):

        localctx = SolidityParser.StorageLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_storageLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 635
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__43) | (1 << SolidityParser.T__44) | (1 << SolidityParser.T__45))) != 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 StateMutabilityContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PureKeyword(self):
            return self.getToken(SolidityParser.PureKeyword, 0)

        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def ViewKeyword(self):
            return self.getToken(SolidityParser.ViewKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateMutability

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStateMutability" ):
                return visitor.visitStateMutability(self)
            else:
                return visitor.visitChildren(self)




    def stateMutability(self):

        localctx = SolidityParser.StateMutabilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_stateMutability)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            _la = self._input.LA(1)
            if not(((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & ((1 << (SolidityParser.ConstantKeyword - 116)) | (1 << (SolidityParser.PayableKeyword - 116)) | (1 << (SolidityParser.PureKeyword - 116)) | (1 << (SolidityParser.ViewKeyword - 116)))) != 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 BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StatementContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StatementContext,i)


        def uncheckedBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UncheckedBlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UncheckedBlockContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_block

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlock" ):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)




    def block(self):

        localctx = SolidityParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.match(SolidityParser.T__13)
            self.state = 644
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__46) | (1 << SolidityParser.T__47) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__51) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60) | (1 << SolidityParser.T__61) | (1 << SolidityParser.T__62))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SolidityParser.T__63 - 64)) | (1 << (SolidityParser.T__64 - 64)) | (1 << (SolidityParser.T__65 - 64)) | (1 << (SolidityParser.T__66 - 64)) | (1 << (SolidityParser.T__67 - 64)) | (1 << (SolidityParser.T__68 - 64)) | (1 << (SolidityParser.Int - 64)) | (1 << (SolidityParser.Uint - 64)) | (1 << (SolidityParser.Byte - 64)) | (1 << (SolidityParser.Fixed - 64)) | (1 << (SolidityParser.Ufixed - 64)) | (1 << (SolidityParser.BooleanLiteral - 64)) | (1 << (SolidityParser.DecimalNumber - 64)) | (1 << (SolidityParser.HexNumber - 64)) | (1 << (SolidityParser.HexLiteral - 64)) | (1 << (SolidityParser.BreakKeyword - 64)) | (1 << (SolidityParser.ContinueKeyword - 64)) | (1 << (SolidityParser.PayableKeyword - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SolidityParser.TypeKeyword - 128)) | (1 << (SolidityParser.Identifier - 128)) | (1 << (SolidityParser.StringLiteral - 128)) | (1 << (SolidityParser.LINE_COMMENT - 128)) | (1 << (SolidityParser.COMMENT - 128)))) != 0):
                self.state = 642
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__13, SolidityParser.T__21, SolidityParser.T__27, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__47, SolidityParser.T__48, SolidityParser.T__49, SolidityParser.T__51, SolidityParser.T__52, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.BreakKeyword, SolidityParser.ContinueKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral, SolidityParser.LINE_COMMENT, SolidityParser.COMMENT]:
                    self.state = 640
                    self.statement()
                    pass
                elif token in [SolidityParser.T__46]:
                    self.state = 641
                    self.uncheckedBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 646
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 647
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UncheckedBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_uncheckedBlock

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUncheckedBlock" ):
                return visitor.visitUncheckedBlock(self)
            else:
                return visitor.visitChildren(self)




    def uncheckedBlock(self):

        localctx = SolidityParser.UncheckedBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_uncheckedBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 649
            self.match(SolidityParser.T__46)
            self.state = 650
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ifStatement(self):
            return self.getTypedRuleContext(SolidityParser.IfStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(SolidityParser.ForStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def inlineAssemblyStatement(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0)


        def doWhileStatement(self):
            return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0)


        def continueStatement(self):
            return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0)


        def breakStatement(self):
            return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0)


        def returnStatement(self):
            return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0)


        def throwStatement(self):
            return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0)


        def emitStatement(self):
            return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def tryStatement(self):
            return self.getTypedRuleContext(SolidityParser.TryStatementContext,0)


        def catchClause(self):
            return self.getTypedRuleContext(SolidityParser.CatchClauseContext,0)


        def LINE_COMMENT(self):
            return self.getToken(SolidityParser.LINE_COMMENT, 0)

        def COMMENT(self):
            return self.getToken(SolidityParser.COMMENT, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_statement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = SolidityParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_statement)
        try:
            self.state = 668
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__49]:
                self.enterOuterAlt(localctx, 1)
                self.state = 652
                self.ifStatement()
                pass
            elif token in [SolidityParser.T__51]:
                self.enterOuterAlt(localctx, 2)
                self.state = 653
                self.whileStatement()
                pass
            elif token in [SolidityParser.T__27]:
                self.enterOuterAlt(localctx, 3)
                self.state = 654
                self.forStatement()
                pass
            elif token in [SolidityParser.T__13]:
                self.enterOuterAlt(localctx, 4)
                self.state = 655
                self.block()
                pass
            elif token in [SolidityParser.T__52]:
                self.enterOuterAlt(localctx, 5)
                self.state = 656
                self.inlineAssemblyStatement()
                pass
            elif token in [SolidityParser.T__53]:
                self.enterOuterAlt(localctx, 6)
                self.state = 657
                self.doWhileStatement()
                pass
            elif token in [SolidityParser.ContinueKeyword]:
                self.enterOuterAlt(localctx, 7)
                self.state = 658
                self.continueStatement()
                pass
            elif token in [SolidityParser.BreakKeyword]:
                self.enterOuterAlt(localctx, 8)
                self.state = 659
                self.breakStatement()
                pass
            elif token in [SolidityParser.T__54]:
                self.enterOuterAlt(localctx, 9)
                self.state = 660
                self.returnStatement()
                pass
            elif token in [SolidityParser.T__55]:
                self.enterOuterAlt(localctx, 10)
                self.state = 661
                self.throwStatement()
                pass
            elif token in [SolidityParser.T__56]:
                self.enterOuterAlt(localctx, 11)
                self.state = 662
                self.emitStatement()
                pass
            elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 12)
                self.state = 663
                self.simpleStatement()
                pass
            elif token in [SolidityParser.T__47]:
                self.enterOuterAlt(localctx, 13)
                self.state = 664
                self.tryStatement()
                pass
            elif token in [SolidityParser.T__48]:
                self.enterOuterAlt(localctx, 14)
                self.state = 665
                self.catchClause()
                pass
            elif token in [SolidityParser.LINE_COMMENT]:
                self.enterOuterAlt(localctx, 15)
                self.state = 666
                self.match(SolidityParser.LINE_COMMENT)
                pass
            elif token in [SolidityParser.COMMENT]:
                self.enterOuterAlt(localctx, 16)
                self.state = 667
                self.match(SolidityParser.COMMENT)
                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 TryStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


        def catchClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.CatchClauseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.CatchClauseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tryStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTryStatement" ):
                return visitor.visitTryStatement(self)
            else:
                return visitor.visitChildren(self)




    def tryStatement(self):

        localctx = SolidityParser.TryStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_tryStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 670
            self.match(SolidityParser.T__47)
            self.state = 671
            self.expression(0)
            self.state = 677
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__34:
                self.state = 672
                self.match(SolidityParser.T__34)
                self.state = 673
                self.match(SolidityParser.T__21)
                self.state = 674
                self.parameterList()
                self.state = 675
                self.match(SolidityParser.T__22)


            self.state = 679
            self.block()
            self.state = 683
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,74,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 680
                    self.catchClause() 
                self.state = 685
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,74,self._ctx)

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


    class CatchClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(SolidityParser.ParameterListContext,0)


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


        def natSpec(self):
            return self.getTypedRuleContext(SolidityParser.NatSpecContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_catchClause

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCatchClause" ):
                return visitor.visitCatchClause(self)
            else:
                return visitor.visitChildren(self)




    def catchClause(self):

        localctx = SolidityParser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_catchClause)
        self._la = 0 # Token type
        try:
            self.state = 702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 686
                self.match(SolidityParser.T__48)
                self.state = 697
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__45))) != 0) or _la==SolidityParser.Identifier:
                    self.state = 688
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                        self.state = 687
                        self.identifier()


                    self.state = 690
                    self.match(SolidityParser.T__21)
                    self.state = 691
                    self.parameterList()
                    self.state = 693
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SolidityParser.NatSpecSingleLine or _la==SolidityParser.NatSpecMultiLine:
                        self.state = 692
                        self.natSpec()


                    self.state = 695
                    self.match(SolidityParser.T__22)


                self.state = 699
                self.block()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 700
                self.match(SolidityParser.T__48)
                self.state = 701
                self.block()
                pass


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


    class ExpressionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionStatement" ):
                return visitor.visitExpressionStatement(self)
            else:
                return visitor.visitChildren(self)




    def expressionStatement(self):

        localctx = SolidityParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 704
            self.expression(0)
            self.state = 705
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ifCondition(self):
            return self.getTypedRuleContext(SolidityParser.IfConditionContext,0)


        def ifRight(self):
            return self.getTypedRuleContext(SolidityParser.IfRightContext,0)


        def ifWrong(self):
            return self.getTypedRuleContext(SolidityParser.IfWrongContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_ifStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfStatement" ):
                return visitor.visitIfStatement(self)
            else:
                return visitor.visitChildren(self)




    def ifStatement(self):

        localctx = SolidityParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_ifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 707
            self.match(SolidityParser.T__49)
            self.state = 708
            self.match(SolidityParser.T__21)
            self.state = 709
            self.ifCondition()
            self.state = 710
            self.match(SolidityParser.T__22)
            self.state = 711
            self.ifRight()
            self.state = 714
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 712
                self.match(SolidityParser.T__50)
                self.state = 713
                self.ifWrong()


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


    class IfConditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_ifCondition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfCondition" ):
                return visitor.visitIfCondition(self)
            else:
                return visitor.visitChildren(self)




    def ifCondition(self):

        localctx = SolidityParser.IfConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_ifCondition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfRightContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_ifRight

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfRight" ):
                return visitor.visitIfRight(self)
            else:
                return visitor.visitChildren(self)




    def ifRight(self):

        localctx = SolidityParser.IfRightContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_ifRight)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 718
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfWrongContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_ifWrong

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfWrong" ):
                return visitor.visitIfWrong(self)
            else:
                return visitor.visitChildren(self)




    def ifWrong(self):

        localctx = SolidityParser.IfWrongContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_ifWrong)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_whileStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhileStatement" ):
                return visitor.visitWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def whileStatement(self):

        localctx = SolidityParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 722
            self.match(SolidityParser.T__51)
            self.state = 723
            self.match(SolidityParser.T__21)
            self.state = 724
            self.expression(0)
            self.state = 725
            self.match(SolidityParser.T__22)
            self.state = 726
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclarationStatement(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_simpleStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleStatement" ):
                return visitor.visitSimpleStatement(self)
            else:
                return visitor.visitChildren(self)




    def simpleStatement(self):

        localctx = SolidityParser.SimpleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_simpleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 728
                self.variableDeclarationStatement()
                pass

            elif la_ == 2:
                self.state = 729
                self.expressionStatement()
                pass


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


    class ForStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionStatementContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_forStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForStatement" ):
                return visitor.visitForStatement(self)
            else:
                return visitor.visitChildren(self)




    def forStatement(self):

        localctx = SolidityParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 732
            self.match(SolidityParser.T__27)
            self.state = 733
            self.match(SolidityParser.T__21)
            self.state = 736
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__31, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__41, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 734
                self.simpleStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 735
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 740
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 738
                self.expressionStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 739
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 743
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                self.state = 742
                self.expression(0)


            self.state = 745
            self.match(SolidityParser.T__22)
            self.state = 746
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineAssemblyStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineAssemblyStatement" ):
                return visitor.visitInlineAssemblyStatement(self)
            else:
                return visitor.visitChildren(self)




    def inlineAssemblyStatement(self):

        localctx = SolidityParser.InlineAssemblyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_inlineAssemblyStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 748
            self.match(SolidityParser.T__52)
            self.state = 750
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.StringLiteral:
                self.state = 749
                self.match(SolidityParser.StringLiteral)


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


    class DoWhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement(self):
            return self.getTypedRuleContext(SolidityParser.StatementContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_doWhileStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDoWhileStatement" ):
                return visitor.visitDoWhileStatement(self)
            else:
                return visitor.visitChildren(self)




    def doWhileStatement(self):

        localctx = SolidityParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_doWhileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 754
            self.match(SolidityParser.T__53)
            self.state = 755
            self.statement()
            self.state = 756
            self.match(SolidityParser.T__51)
            self.state = 757
            self.match(SolidityParser.T__21)
            self.state = 758
            self.expression(0)
            self.state = 759
            self.match(SolidityParser.T__22)
            self.state = 760
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContinueStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_continueStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContinueStatement" ):
                return visitor.visitContinueStatement(self)
            else:
                return visitor.visitChildren(self)




    def continueStatement(self):

        localctx = SolidityParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_continueStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 762
            self.match(SolidityParser.ContinueKeyword)
            self.state = 763
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BreakStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_breakStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBreakStatement" ):
                return visitor.visitBreakStatement(self)
            else:
                return visitor.visitChildren(self)




    def breakStatement(self):

        localctx = SolidityParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 765
            self.match(SolidityParser.BreakKeyword)
            self.state = 766
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnStatement" ):
                return visitor.visitReturnStatement(self)
            else:
                return visitor.visitChildren(self)




    def returnStatement(self):

        localctx = SolidityParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 768
            self.match(SolidityParser.T__54)
            self.state = 770
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                self.state = 769
                self.expression(0)


            self.state = 772
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_throwStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrowStatement" ):
                return visitor.visitThrowStatement(self)
            else:
                return visitor.visitChildren(self)




    def throwStatement(self):

        localctx = SolidityParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_throwStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 774
            self.match(SolidityParser.T__55)
            self.state = 775
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmitStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionCall(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_emitStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmitStatement" ):
                return visitor.visitEmitStatement(self)
            else:
                return visitor.visitChildren(self)




    def emitStatement(self):

        localctx = SolidityParser.EmitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_emitStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 777
            self.match(SolidityParser.T__56)
            self.state = 778
            self.functionCall()
            self.state = 779
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifierList(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierListContext,0)


        def variableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0)


        def variableDeclarationList(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationStatement

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationStatement" ):
                return visitor.visitVariableDeclarationStatement(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationStatement(self):

        localctx = SolidityParser.VariableDeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_variableDeclarationStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 788
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 781
                self.match(SolidityParser.T__57)
                self.state = 782
                self.identifierList()
                pass

            elif la_ == 2:
                self.state = 783
                self.variableDeclaration()
                pass

            elif la_ == 3:
                self.state = 784
                self.match(SolidityParser.T__21)
                self.state = 785
                self.variableDeclarationList()
                self.state = 786
                self.match(SolidityParser.T__22)
                pass


            self.state = 792
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__8:
                self.state = 790
                self.match(SolidityParser.T__8)
                self.state = 791
                self.expression(0)


            self.state = 794
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantVariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

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


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_constantVariableDeclaration

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstantVariableDeclaration" ):
                return visitor.visitConstantVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def constantVariableDeclaration(self):

        localctx = SolidityParser.ConstantVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_constantVariableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 796
            self.typeName(0)
            self.state = 797
            self.match(SolidityParser.ConstantKeyword)
            self.state = 798
            self.identifier()
            self.state = 799
            self.match(SolidityParser.T__8)
            self.state = 800
            self.expression(0)
            self.state = 801
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDeclarationList" ):
                return visitor.visitVariableDeclarationList(self)
            else:
                return visitor.visitChildren(self)




    def variableDeclarationList(self):

        localctx = SolidityParser.VariableDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_variableDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 804
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                self.state = 803
                self.variableDeclaration()


            self.state = 812
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 806
                self.match(SolidityParser.T__14)
                self.state = 808
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)) | (1 << (SolidityParser.Identifier - 102)))) != 0):
                    self.state = 807
                    self.variableDeclaration()


                self.state = 814
                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 IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_identifierList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifierList" ):
                return visitor.visitIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def identifierList(self):

        localctx = SolidityParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 815
            self.match(SolidityParser.T__21)
            self.state = 822
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,92,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 817
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                        self.state = 816
                        self.identifier()


                    self.state = 819
                    self.match(SolidityParser.T__14) 
                self.state = 824
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 825
                self.identifier()


            self.state = 828
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementaryTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Int(self):
            return self.getToken(SolidityParser.Int, 0)

        def Uint(self):
            return self.getToken(SolidityParser.Uint, 0)

        def Byte(self):
            return self.getToken(SolidityParser.Byte, 0)

        def Fixed(self):
            return self.getToken(SolidityParser.Fixed, 0)

        def Ufixed(self):
            return self.getToken(SolidityParser.Ufixed, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_elementaryTypeName

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElementaryTypeName" ):
                return visitor.visitElementaryTypeName(self)
            else:
                return visitor.visitChildren(self)




    def elementaryTypeName(self):

        localctx = SolidityParser.ElementaryTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_elementaryTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 830
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__39) | (1 << SolidityParser.T__57) | (1 << SolidityParser.T__58) | (1 << SolidityParser.T__59) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SolidityParser.Int - 102)) | (1 << (SolidityParser.Uint - 102)) | (1 << (SolidityParser.Byte - 102)) | (1 << (SolidityParser.Fixed - 102)) | (1 << (SolidityParser.Ufixed - 102)))) != 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 ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def callArgumentList(self):
            return self.getTypedRuleContext(SolidityParser.CallArgumentListContext,0)


        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


        def primaryExpression(self):
            return self.getTypedRuleContext(SolidityParser.PrimaryExpressionContext,0)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 136
        self.enterRecursionRule(localctx, 136, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 868
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
            if la_ == 1:
                self.state = 833
                self.match(SolidityParser.T__37)
                self.state = 834
                self.expression(0)
                self.state = 839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 835
                    self.match(SolidityParser.T__14)
                    self.state = 836
                    self.expression(0)
                    self.state = 841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 842
                self.match(SolidityParser.T__38)
                pass

            elif la_ == 2:
                self.state = 844
                self.match(SolidityParser.PayableKeyword)
                self.state = 845
                self.callArgumentList()
                pass

            elif la_ == 3:
                self.state = 846
                self.match(SolidityParser.TypeKeyword)
                self.state = 847
                self.match(SolidityParser.T__21)
                self.state = 848
                self.typeName(0)
                self.state = 849
                self.match(SolidityParser.T__22)
                pass

            elif la_ == 4:
                self.state = 851
                _la = self._input.LA(1)
                if not(((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 852
                self.expression(23)
                pass

            elif la_ == 5:
                self.state = 853
                self.match(SolidityParser.T__66)
                self.state = 854
                self.typeName(0)
                pass

            elif la_ == 6:
                self.state = 855
                self.match(SolidityParser.T__21)
                self.state = 856
                self.expression(0)
                self.state = 857
                self.match(SolidityParser.T__22)
                pass

            elif la_ == 7:
                self.state = 859
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__65 or _la==SolidityParser.T__67):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 860
                self.expression(18)
                pass

            elif la_ == 8:
                self.state = 861
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__64 or _la==SolidityParser.T__68):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 862
                self.expression(17)
                pass

            elif la_ == 9:
                self.state = 863
                self.match(SolidityParser.T__63)
                self.state = 864
                self.expression(16)
                pass

            elif la_ == 10:
                self.state = 865
                self.match(SolidityParser.T__3)
                self.state = 866
                self.expression(15)
                pass

            elif la_ == 11:
                self.state = 867
                self.primaryExpression()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 961
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 959
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
                    if la_ == 1:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 870
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 871
                        self.match(SolidityParser.T__69)
                        self.state = 872
                        self.expression(15)
                        pass

                    elif la_ == 2:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 873
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 874
                        _la = self._input.LA(1)
                        if not(((((_la - 12)) & ~0x3f) == 0 and ((1 << (_la - 12)) & ((1 << (SolidityParser.T__11 - 12)) | (1 << (SolidityParser.T__70 - 12)) | (1 << (SolidityParser.T__71 - 12)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 875
                        self.expression(14)
                        pass

                    elif la_ == 3:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 876
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 877
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__65 or _la==SolidityParser.T__67):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 878
                        self.expression(13)
                        pass

                    elif la_ == 4:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 879
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 880
                        _la = self._input.LA(1)
                        if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (SolidityParser.T__72 - 73)) | (1 << (SolidityParser.T__73 - 73)) | (1 << (SolidityParser.T__74 - 73)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 881
                        self.expression(12)
                        pass

                    elif la_ == 5:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 882
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 883
                        self.match(SolidityParser.T__75)
                        self.state = 884
                        self.expression(11)
                        pass

                    elif la_ == 6:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 885
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 886
                        self.match(SolidityParser.T__2)
                        self.state = 887
                        self.expression(10)
                        pass

                    elif la_ == 7:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 888
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 889
                        self.match(SolidityParser.T__76)
                        self.state = 890
                        self.expression(9)
                        pass

                    elif la_ == 8:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 891
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 892
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 893
                        self.expression(8)
                        pass

                    elif la_ == 9:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 894
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 895
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__77 or _la==SolidityParser.T__78):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 896
                        self.expression(7)
                        pass

                    elif la_ == 10:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 897
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 898
                        self.match(SolidityParser.T__79)
                        self.state = 899
                        self.expression(6)
                        pass

                    elif la_ == 11:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 900
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 901
                        self.match(SolidityParser.T__80)
                        self.state = 902
                        self.expression(5)
                        pass

                    elif la_ == 12:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 903
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 904
                        self.match(SolidityParser.T__81)
                        self.state = 905
                        self.expression(0)
                        self.state = 906
                        self.match(SolidityParser.T__24)
                        self.state = 907
                        self.expression(4)
                        pass

                    elif la_ == 13:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 909
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 910
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__8 or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (SolidityParser.T__82 - 83)) | (1 << (SolidityParser.T__83 - 83)) | (1 << (SolidityParser.T__84 - 83)) | (1 << (SolidityParser.T__85 - 83)) | (1 << (SolidityParser.T__86 - 83)) | (1 << (SolidityParser.T__87 - 83)) | (1 << (SolidityParser.T__88 - 83)) | (1 << (SolidityParser.T__89 - 83)) | (1 << (SolidityParser.T__90 - 83)) | (1 << (SolidityParser.T__91 - 83)) | (1 << (SolidityParser.T__92 - 83)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 911
                        self.expression(3)
                        pass

                    elif la_ == 14:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 912
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 913
                        self.match(SolidityParser.T__37)
                        self.state = 915
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                            self.state = 914
                            self.expression(0)


                        self.state = 917
                        self.match(SolidityParser.T__38)
                        pass

                    elif la_ == 15:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 918
                        if not self.precpred(self._ctx, 28):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 28)")
                        self.state = 919
                        self.match(SolidityParser.T__37)
                        self.state = 921
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                            self.state = 920
                            self.expression(0)


                        self.state = 923
                        self.match(SolidityParser.T__24)
                        self.state = 925
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                            self.state = 924
                            self.expression(0)


                        self.state = 927
                        self.match(SolidityParser.T__38)
                        pass

                    elif la_ == 16:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 928
                        if not self.precpred(self._ctx, 27):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 27)")
                        self.state = 929
                        self.match(SolidityParser.T__40)
                        self.state = 932
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                            self.state = 930
                            self.identifier()
                            pass
                        elif token in [SolidityParser.T__39]:
                            self.state = 931
                            self.match(SolidityParser.T__39)
                            pass
                        else:
                            raise NoViableAltException(self)

                        pass

                    elif la_ == 17:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 934
                        if not self.precpred(self._ctx, 26):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 26)")
                        self.state = 935
                        self.match(SolidityParser.T__13)
                        self.state = 949
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                            self.state = 936
                            self.identifier()
                            self.state = 937
                            self.match(SolidityParser.T__24)
                            self.state = 938
                            self.expression(0)
                            self.state = 946
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            while _la==SolidityParser.T__14:
                                self.state = 939
                                self.match(SolidityParser.T__14)
                                self.state = 940
                                self.identifier()
                                self.state = 941
                                self.match(SolidityParser.T__24)
                                self.state = 942
                                self.expression(0)
                                self.state = 948
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)



                        self.state = 951
                        self.match(SolidityParser.T__15)
                        pass

                    elif la_ == 18:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 952
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 953
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__61 or _la==SolidityParser.T__62):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

                    elif la_ == 19:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 954
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 955
                        self.match(SolidityParser.T__21)
                        self.state = 956
                        self.functionCallArguments()
                        self.state = 957
                        self.match(SolidityParser.T__22)
                        pass

             
                self.state = 963
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,103,self._ctx)

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


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BooleanLiteral(self):
            return self.getToken(SolidityParser.BooleanLiteral, 0)

        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

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


        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def tupleExpression(self):
            return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0)


        def typeNameExpression(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_primaryExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimaryExpression" ):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def primaryExpression(self):

        localctx = SolidityParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_primaryExpression)
        try:
            self.state = 980
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 964
                self.match(SolidityParser.BooleanLiteral)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 965
                self.numberLiteral()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 966
                self.match(SolidityParser.HexLiteral)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 967
                self.match(SolidityParser.StringLiteral)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 968
                self.identifier()
                self.state = 971
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
                if la_ == 1:
                    self.state = 969
                    self.match(SolidityParser.T__37)
                    self.state = 970
                    self.match(SolidityParser.T__38)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 973
                self.match(SolidityParser.TypeKeyword)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 974
                self.tupleExpression()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 975
                self.typeNameExpression()
                self.state = 978
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
                if la_ == 1:
                    self.state = 976
                    self.match(SolidityParser.T__37)
                    self.state = 977
                    self.match(SolidityParser.T__38)


                pass


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


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionList" ):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)




    def expressionList(self):

        localctx = SolidityParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 982
            self.expression(0)
            self.state = 987
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 983
                self.match(SolidityParser.T__14)
                self.state = 984
                self.expression(0)
                self.state = 989
                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 NameValueListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.NameValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.NameValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValueList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValueList" ):
                return visitor.visitNameValueList(self)
            else:
                return visitor.visitChildren(self)




    def nameValueList(self):

        localctx = SolidityParser.NameValueListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_nameValueList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 990
            self.nameValue()
            self.state = 995
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,108,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 991
                    self.match(SolidityParser.T__14)
                    self.state = 992
                    self.nameValue() 
                self.state = 997
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,self._ctx)

            self.state = 999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__14:
                self.state = 998
                self.match(SolidityParser.T__14)


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


    class NameValueContext(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(SolidityParser.IdentifierContext,0)


        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValue

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNameValue" ):
                return visitor.visitNameValue(self)
            else:
                return visitor.visitChildren(self)




    def nameValue(self):

        localctx = SolidityParser.NameValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_nameValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1001
            self.identifier()
            self.state = 1002
            self.match(SolidityParser.T__24)
            self.state = 1003
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCallArguments

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCallArguments" ):
                return visitor.visitFunctionCallArguments(self)
            else:
                return visitor.visitChildren(self)




    def functionCallArguments(self):

        localctx = SolidityParser.FunctionCallArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_functionCallArguments)
        self._la = 0 # Token type
        try:
            self.state = 1013
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1005
                self.match(SolidityParser.T__13)
                self.state = 1007
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                    self.state = 1006
                    self.nameValueList()


                self.state = 1009
                self.match(SolidityParser.T__15)
                pass
            elif token in [SolidityParser.T__3, SolidityParser.T__12, SolidityParser.T__21, SolidityParser.T__22, SolidityParser.T__37, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__61, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__67, SolidityParser.T__68, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1011
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                    self.state = 1010
                    self.expressionList()


                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 FunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCall

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionCall" ):
                return visitor.visitFunctionCall(self)
            else:
                return visitor.visitChildren(self)




    def functionCall(self):

        localctx = SolidityParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1015
            self.expression(0)
            self.state = 1016
            self.match(SolidityParser.T__21)
            self.state = 1017
            self.functionCallArguments()
            self.state = 1018
            self.match(SolidityParser.T__22)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyBlock

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyBlock" ):
                return visitor.visitAssemblyBlock(self)
            else:
                return visitor.visitChildren(self)




    def assemblyBlock(self):

        localctx = SolidityParser.AssemblyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_assemblyBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            self.match(SolidityParser.T__13)
            self.state = 1024
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__21) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__49) | (1 << SolidityParser.T__52) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & ((1 << (SolidityParser.T__93 - 94)) | (1 << (SolidityParser.T__95 - 94)) | (1 << (SolidityParser.T__96 - 94)) | (1 << (SolidityParser.DecimalNumber - 94)) | (1 << (SolidityParser.HexNumber - 94)) | (1 << (SolidityParser.HexLiteral - 94)) | (1 << (SolidityParser.BreakKeyword - 94)) | (1 << (SolidityParser.ContinueKeyword - 94)) | (1 << (SolidityParser.Identifier - 94)) | (1 << (SolidityParser.StringLiteral - 94)))) != 0):
                self.state = 1021
                self.assemblyItem()
                self.state = 1026
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1027
            self.match(SolidityParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyItemContext(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(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyLocalDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0)


        def assemblyAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0)


        def assemblyStackAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0)


        def labelDefinition(self):
            return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0)


        def assemblySwitch(self):
            return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0)


        def assemblyFunctionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0)


        def assemblyFor(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0)


        def assemblyIf(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0)


        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def subAssembly(self):
            return self.getTypedRuleContext(SolidityParser.SubAssemblyContext,0)


        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyItem

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyItem" ):
                return visitor.visitAssemblyItem(self)
            else:
                return visitor.visitChildren(self)




    def assemblyItem(self):

        localctx = SolidityParser.AssemblyItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_assemblyItem)
        try:
            self.state = 1046
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1029
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1030
                self.assemblyBlock()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1031
                self.assemblyExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1032
                self.assemblyLocalDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1033
                self.assemblyAssignment()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1034
                self.assemblyStackAssignment()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1035
                self.labelDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1036
                self.assemblySwitch()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1037
                self.assemblyFunctionDefinition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1038
                self.assemblyFor()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1039
                self.assemblyIf()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1040
                self.match(SolidityParser.BreakKeyword)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1041
                self.match(SolidityParser.ContinueKeyword)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1042
                self.subAssembly()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1043
                self.numberLiteral()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1044
                self.match(SolidityParser.StringLiteral)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1045
                self.match(SolidityParser.HexLiteral)
                pass


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


    class AssemblyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyCall(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyCallContext,0)


        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyExpression" ):
                return visitor.visitAssemblyExpression(self)
            else:
                return visitor.visitChildren(self)




    def assemblyExpression(self):

        localctx = SolidityParser.AssemblyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_assemblyExpression)
        try:
            self.state = 1050
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1048
                self.assemblyCall()
                pass
            elif token in [SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1049
                self.assemblyLiteral()
                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 AssemblyCallContext(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(SolidityParser.IdentifierContext,0)


        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCall

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCall" ):
                return visitor.visitAssemblyCall(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCall(self):

        localctx = SolidityParser.AssemblyCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_assemblyCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1056
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__54]:
                self.state = 1052
                self.match(SolidityParser.T__54)
                pass
            elif token in [SolidityParser.T__39]:
                self.state = 1053
                self.match(SolidityParser.T__39)
                pass
            elif token in [SolidityParser.T__60]:
                self.state = 1054
                self.match(SolidityParser.T__60)
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                self.state = 1055
                self.identifier()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1070
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.state = 1058
                self.match(SolidityParser.T__21)
                self.state = 1060
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__12) | (1 << SolidityParser.T__39) | (1 << SolidityParser.T__45) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__60))) != 0) or ((((_la - 109)) & ~0x3f) == 0 and ((1 << (_la - 109)) & ((1 << (SolidityParser.DecimalNumber - 109)) | (1 << (SolidityParser.HexNumber - 109)) | (1 << (SolidityParser.HexLiteral - 109)) | (1 << (SolidityParser.Identifier - 109)) | (1 << (SolidityParser.StringLiteral - 109)))) != 0):
                    self.state = 1059
                    self.assemblyExpression()


                self.state = 1066
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 1062
                    self.match(SolidityParser.T__14)
                    self.state = 1063
                    self.assemblyExpression()
                    self.state = 1068
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1069
                self.match(SolidityParser.T__22)


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


    class AssemblyLocalDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLocalDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLocalDefinition" ):
                return visitor.visitAssemblyLocalDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLocalDefinition(self):

        localctx = SolidityParser.AssemblyLocalDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_assemblyLocalDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1072
            self.match(SolidityParser.T__93)
            self.state = 1073
            self.assemblyIdentifierOrList()
            self.state = 1076
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__94:
                self.state = 1074
                self.match(SolidityParser.T__94)
                self.state = 1075
                self.assemblyExpression()


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


    class AssemblyAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyAssignment

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyAssignment" ):
                return visitor.visitAssemblyAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyAssignment(self):

        localctx = SolidityParser.AssemblyAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_assemblyAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078
            self.assemblyIdentifierOrList()
            self.state = 1079
            self.match(SolidityParser.T__94)
            self.state = 1080
            self.assemblyExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierOrListContext(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(SolidityParser.IdentifierContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierOrList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierOrList" ):
                return visitor.visitAssemblyIdentifierOrList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierOrList(self):

        localctx = SolidityParser.AssemblyIdentifierOrListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_assemblyIdentifierOrList)
        try:
            self.state = 1087
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1082
                self.identifier()
                pass
            elif token in [SolidityParser.T__21]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1083
                self.match(SolidityParser.T__21)
                self.state = 1084
                self.assemblyIdentifierList()
                self.state = 1085
                self.match(SolidityParser.T__22)
                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 AssemblyIdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierList

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIdentifierList" ):
                return visitor.visitAssemblyIdentifierList(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIdentifierList(self):

        localctx = SolidityParser.AssemblyIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_assemblyIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1089
            self.identifier()
            self.state = 1094
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__14:
                self.state = 1090
                self.match(SolidityParser.T__14)
                self.state = 1091
                self.identifier()
                self.state = 1096
                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 AssemblyStackAssignmentContext(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(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyStackAssignment

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyStackAssignment" ):
                return visitor.visitAssemblyStackAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assemblyStackAssignment(self):

        localctx = SolidityParser.AssemblyStackAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_assemblyStackAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            self.match(SolidityParser.T__95)
            self.state = 1098
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_labelDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabelDefinition" ):
                return visitor.visitLabelDefinition(self)
            else:
                return visitor.visitChildren(self)




    def labelDefinition(self):

        localctx = SolidityParser.LabelDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_labelDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1100
            self.identifier()
            self.state = 1101
            self.match(SolidityParser.T__24)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblySwitchContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyCase(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblySwitch

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblySwitch" ):
                return visitor.visitAssemblySwitch(self)
            else:
                return visitor.visitChildren(self)




    def assemblySwitch(self):

        localctx = SolidityParser.AssemblySwitchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_assemblySwitch)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1103
            self.match(SolidityParser.T__96)
            self.state = 1104
            self.assemblyExpression()
            self.state = 1108
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__97 or _la==SolidityParser.T__98:
                self.state = 1105
                self.assemblyCase()
                self.state = 1110
                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 AssemblyCaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCase

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyCase" ):
                return visitor.visitAssemblyCase(self)
            else:
                return visitor.visitChildren(self)




    def assemblyCase(self):

        localctx = SolidityParser.AssemblyCaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_assemblyCase)
        try:
            self.state = 1117
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__97]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1111
                self.match(SolidityParser.T__97)
                self.state = 1112
                self.assemblyLiteral()
                self.state = 1113
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__98]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1115
                self.match(SolidityParser.T__98)
                self.state = 1116
                self.assemblyBlock()
                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 AssemblyFunctionDefinitionContext(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(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def assemblyFunctionReturns(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionDefinition

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionDefinition" ):
                return visitor.visitAssemblyFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionDefinition(self):

        localctx = SolidityParser.AssemblyFunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_assemblyFunctionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1119
            self.match(SolidityParser.T__31)
            self.state = 1120
            self.identifier()
            self.state = 1121
            self.match(SolidityParser.T__21)
            self.state = 1123
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier:
                self.state = 1122
                self.assemblyIdentifierList()


            self.state = 1125
            self.match(SolidityParser.T__22)
            self.state = 1127
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__99:
                self.state = 1126
                self.assemblyFunctionReturns()


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


    class AssemblyFunctionReturnsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionReturns

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFunctionReturns" ):
                return visitor.visitAssemblyFunctionReturns(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFunctionReturns(self):

        localctx = SolidityParser.AssemblyFunctionReturnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_assemblyFunctionReturns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1131
            self.match(SolidityParser.T__99)
            self.state = 1132
            self.assemblyIdentifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def assemblyBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyFor" ):
                return visitor.visitAssemblyFor(self)
            else:
                return visitor.visitChildren(self)




    def assemblyFor(self):

        localctx = SolidityParser.AssemblyForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_assemblyFor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1134
            self.match(SolidityParser.T__27)
            self.state = 1137
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.state = 1135
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 1136
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1139
            self.assemblyExpression()
            self.state = 1142
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13]:
                self.state = 1140
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__39, SolidityParser.T__45, SolidityParser.T__54, SolidityParser.T__60, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteral, SolidityParser.Identifier, SolidityParser.StringLiteral]:
                self.state = 1141
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

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


    class AssemblyIfContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIf

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyIf" ):
                return visitor.visitAssemblyIf(self)
            else:
                return visitor.visitChildren(self)




    def assemblyIf(self):

        localctx = SolidityParser.AssemblyIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_assemblyIf)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1146
            self.match(SolidityParser.T__49)
            self.state = 1147
            self.assemblyExpression()
            self.state = 1148
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StringLiteral(self):
            return self.getToken(SolidityParser.StringLiteral, 0)

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def HexLiteral(self):
            return self.getToken(SolidityParser.HexLiteral, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssemblyLiteral" ):
                return visitor.visitAssemblyLiteral(self)
            else:
                return visitor.visitChildren(self)




    def assemblyLiteral(self):

        localctx = SolidityParser.AssemblyLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_assemblyLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1150
            _la = self._input.LA(1)
            if not(((((_la - 109)) & ~0x3f) == 0 and ((1 << (_la - 109)) & ((1 << (SolidityParser.DecimalNumber - 109)) | (1 << (SolidityParser.HexNumber - 109)) | (1 << (SolidityParser.HexLiteral - 109)) | (1 << (SolidityParser.StringLiteral - 109)))) != 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 SubAssemblyContext(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(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_subAssembly

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubAssembly" ):
                return visitor.visitSubAssembly(self)
            else:
                return visitor.visitChildren(self)




    def subAssembly(self):

        localctx = SolidityParser.SubAssemblyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_subAssembly)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1152
            self.match(SolidityParser.T__52)
            self.state = 1153
            self.identifier()
            self.state = 1154
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TupleExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tupleExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTupleExpression" ):
                return visitor.visitTupleExpression(self)
            else:
                return visitor.visitChildren(self)




    def tupleExpression(self):

        localctx = SolidityParser.TupleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_tupleExpression)
        self._la = 0 # Token type
        try:
            self.state = 1182
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__21]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1156
                self.match(SolidityParser.T__21)

                self.state = 1158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                    self.state = 1157
                    self.expression(0)


                self.state = 1166
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__14:
                    self.state = 1160
                    self.match(SolidityParser.T__14)
                    self.state = 1162
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                        self.state = 1161
                        self.expression(0)


                    self.state = 1168
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1169
                self.match(SolidityParser.T__22)
                pass
            elif token in [SolidityParser.T__37]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1170
                self.match(SolidityParser.T__37)
                self.state = 1179
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (SolidityParser.T__3 - 4)) | (1 << (SolidityParser.T__12 - 4)) | (1 << (SolidityParser.T__21 - 4)) | (1 << (SolidityParser.T__37 - 4)) | (1 << (SolidityParser.T__39 - 4)) | (1 << (SolidityParser.T__45 - 4)) | (1 << (SolidityParser.T__57 - 4)) | (1 << (SolidityParser.T__58 - 4)) | (1 << (SolidityParser.T__59 - 4)) | (1 << (SolidityParser.T__60 - 4)) | (1 << (SolidityParser.T__61 - 4)) | (1 << (SolidityParser.T__62 - 4)) | (1 << (SolidityParser.T__63 - 4)) | (1 << (SolidityParser.T__64 - 4)) | (1 << (SolidityParser.T__65 - 4)) | (1 << (SolidityParser.T__66 - 4)))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (SolidityParser.T__67 - 68)) | (1 << (SolidityParser.T__68 - 68)) | (1 << (SolidityParser.Int - 68)) | (1 << (SolidityParser.Uint - 68)) | (1 << (SolidityParser.Byte - 68)) | (1 << (SolidityParser.Fixed - 68)) | (1 << (SolidityParser.Ufixed - 68)) | (1 << (SolidityParser.BooleanLiteral - 68)) | (1 << (SolidityParser.DecimalNumber - 68)) | (1 << (SolidityParser.HexNumber - 68)) | (1 << (SolidityParser.HexLiteral - 68)) | (1 << (SolidityParser.PayableKeyword - 68)) | (1 << (SolidityParser.TypeKeyword - 68)) | (1 << (SolidityParser.Identifier - 68)) | (1 << (SolidityParser.StringLiteral - 68)))) != 0):
                    self.state = 1171
                    self.expression(0)
                    self.state = 1176
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SolidityParser.T__14:
                        self.state = 1172
                        self.match(SolidityParser.T__14)
                        self.state = 1173
                        self.expression(0)
                        self.state = 1178
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1181
                self.match(SolidityParser.T__38)
                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 TypeNameExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_typeNameExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeNameExpression" ):
                return visitor.visitTypeNameExpression(self)
            else:
                return visitor.visitChildren(self)




    def typeNameExpression(self):

        localctx = SolidityParser.TypeNameExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_typeNameExpression)
        try:
            self.state = 1186
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__39, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1184
                self.elementaryTypeName()
                pass
            elif token in [SolidityParser.T__12, SolidityParser.T__45, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1185
                self.userDefinedTypeName()
                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 NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def NumberUnit(self):
            return self.getToken(SolidityParser.NumberUnit, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_numberLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumberLiteral" ):
                return visitor.visitNumberLiteral(self)
            else:
                return visitor.visitChildren(self)




    def numberLiteral(self):

        localctx = SolidityParser.NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_numberLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1188
            _la = self._input.LA(1)
            if not(_la==SolidityParser.DecimalNumber or _la==SolidityParser.HexNumber):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1190
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
            if la_ == 1:
                self.state = 1189
                self.match(SolidityParser.NumberUnit)


        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 Identifier(self, i:int=None):
            if i is None:
                return self.getTokens(SolidityParser.Identifier)
            else:
                return self.getToken(SolidityParser.Identifier, i)

        def getRuleIndex(self):
            return SolidityParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdentifier" ):
                return visitor.visitIdentifier(self)
            else:
                return visitor.visitChildren(self)




    def identifier(self):

        localctx = SolidityParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.state = 1201
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1192
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__12 or _la==SolidityParser.T__45 or _la==SolidityParser.Identifier):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1193
                self.match(SolidityParser.Identifier)
                self.state = 1198
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,137,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1194
                        self.match(SolidityParser.T__12)
                        self.state = 1195
                        self.match(SolidityParser.Identifier) 
                    self.state = 1200
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,137,self._ctx)

                pass


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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[36] = self.typeName_sempred
        self._predicates[68] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def typeName_sempred(self, localctx:TypeNameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 30)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 28)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 27)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 26)
         

            if predIndex == 18:
                return self.precpred(self._ctx, 22)
         

            if predIndex == 19:
                return self.precpred(self._ctx, 20)