text: # Generated from UnitX.g4 by ANTLR 4.5.1
  # encoding: utf-8
  from __future__ import print_function
  from antlr4 import *
  from io import StringIO
  
  def serializedATN():
      with StringIO() as buf:
          buf.write(u"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3")
          buf.write(u"V\u0171\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
          buf.write(u"\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
          buf.write(u"\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4")
          buf.write(u"\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30")
          buf.write(u"\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t")
          buf.write(u"\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\3\2\7\2D\n\2\f\2")
          buf.write(u"\16\2G\13\2\3\2\3\2\3\3\3\3\5\3M\n\3\3\4\3\4\3\4\3\4")
          buf.write(u"\3\4\3\5\5\5U\n\5\3\5\3\5\5\5Y\n\5\3\5\5\5\\\n\5\3\6")
          buf.write(u"\3\6\3\6\7\6a\n\6\f\6\16\6d\13\6\3\7\3\7\3\7\5\7i\n\7")
          buf.write(u"\3\b\3\b\7\bm\n\b\f\b\16\bp\13\b\3\b\3\b\3\b\7\bu\n\b")
          buf.write(u"\f\b\16\bx\13\b\3\b\5\b{\n\b\3\t\3\t\3\n\3\n\3\n\3\n")
          buf.write(u"\3\n\5\n\u0084\n\n\3\n\3\n\5\n\u0088\n\n\3\n\5\n\u008b")
          buf.write(u"\n\n\3\n\3\n\5\n\u008f\n\n\3\n\3\n\5\n\u0093\n\n\3\n")
          buf.write(u"\3\n\5\n\u0097\n\n\3\n\3\n\5\n\u009b\n\n\3\n\3\n\5\n")
          buf.write(u"\u009f\n\n\3\n\3\n\5\n\u00a3\n\n\5\n\u00a5\n\n\3\13\3")
          buf.write(u"\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00b1")
          buf.write(u"\n\13\3\f\3\f\3\f\3\f\3\f\5\f\u00b8\n\f\3\r\3\r\3\16")
          buf.write(u"\3\16\5\16\u00be\n\16\3\16\3\16\7\16\u00c2\n\16\f\16")
          buf.write(u"\16\16\u00c5\13\16\3\17\3\17\5\17\u00c9\n\17\3\20\3\20")
          buf.write(u"\3\20\5\20\u00ce\n\20\3\20\3\20\7\20\u00d2\n\20\f\20")
          buf.write(u"\16\20\u00d5\13\20\3\21\3\21\3\22\3\22\3\22\7\22\u00dc")
          buf.write(u"\n\22\f\22\16\22\u00df\13\22\3\23\3\23\3\23\3\23\3\23")
          buf.write(u"\5\23\u00e6\n\23\3\24\3\24\3\24\3\24\3\25\3\25\3\26\3")
          buf.write(u"\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26\u00f6\n\26\3\26")
          buf.write(u"\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3")
          buf.write(u"\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26")
          buf.write(u"\u010d\n\26\3\26\7\26\u0110\n\26\f\26\16\26\u0113\13")
          buf.write(u"\26\3\27\3\27\3\27\3\27\3\30\5\30\u011a\n\30\3\30\3\30")
          buf.write(u"\5\30\u011e\n\30\3\30\3\30\3\30\3\30\5\30\u0124\n\30")
          buf.write(u"\3\31\3\31\3\31\3\31\5\31\u012a\n\31\3\32\3\32\5\32\u012e")
          buf.write(u"\n\32\3\32\3\32\5\32\u0132\n\32\3\32\3\32\3\32\3\32\5")
          buf.write(u"\32\u0138\n\32\3\32\3\32\5\32\u013c\n\32\3\32\3\32\7")
          buf.write(u"\32\u0140\n\32\f\32\16\32\u0143\13\32\3\32\3\32\5\32")
          buf.write(u"\u0147\n\32\5\32\u0149\n\32\3\33\3\33\3\33\3\33\5\33")
          buf.write(u"\u014f\n\33\3\34\3\34\3\34\5\34\u0154\n\34\3\35\3\35")
          buf.write(u"\7\35\u0158\n\35\f\35\16\35\u015b\13\35\3\35\3\35\7\35")
          buf.write(u"\u015f\n\35\f\35\16\35\u0162\13\35\5\35\u0164\n\35\3")
          buf.write(u"\36\3\36\3\36\5\36\u0169\n\36\3\37\3\37\3 \3 \3!\3!\3")
          buf.write(u"!\2\3*\"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&")
          buf.write(u"(*,.\60\62\64\668:<>@\2\16\3\2\33\"\3\2\66\67\3\2&\'")
          buf.write(u"\4\2:;??\3\289\4\2$%./\4\2,-\61\61\5\2##@CGG\3\2\62\65")
          buf.write(u"\4\2\6\6RR\3\2KN\3\2\b\t\u0198\2E\3\2\2\2\4L\3\2\2\2")
          buf.write(u"\6N\3\2\2\2\b[\3\2\2\2\n]\3\2\2\2\fe\3\2\2\2\16z\3\2")
          buf.write(u"\2\2\20|\3\2\2\2\22\u00a4\3\2\2\2\24\u00b0\3\2\2\2\26")
          buf.write(u"\u00b2\3\2\2\2\30\u00b9\3\2\2\2\32\u00bb\3\2\2\2\34\u00c6")
          buf.write(u"\3\2\2\2\36\u00ca\3\2\2\2 \u00d6\3\2\2\2\"\u00d8\3\2")
          buf.write(u"\2\2$\u00e5\3\2\2\2&\u00e7\3\2\2\2(\u00eb\3\2\2\2*\u00f5")
          buf.write(u"\3\2\2\2,\u0114\3\2\2\2.\u0123\3\2\2\2\60\u0129\3\2\2")
          buf.write(u"\2\62\u0148\3\2\2\2\64\u014e\3\2\2\2\66\u0153\3\2\2\2")
          buf.write(u"8\u0163\3\2\2\2:\u0168\3\2\2\2<\u016a\3\2\2\2>\u016c")
          buf.write(u"\3\2\2\2@\u016e\3\2\2\2BD\5\4\3\2CB\3\2\2\2DG\3\2\2\2")
          buf.write(u"EC\3\2\2\2EF\3\2\2\2FH\3\2\2\2GE\3\2\2\2HI\7\2\2\3I\3")
          buf.write(u"\3\2\2\2JM\5\22\n\2KM\5\6\4\2LJ\3\2\2\2LK\3\2\2\2M\5")
          buf.write(u"\3\2\2\2NO\7\13\2\2OP\7Q\2\2PQ\5\b\5\2QR\5\16\b\2R\7")
          buf.write(u"\3\2\2\2SU\5\n\6\2TS\3\2\2\2TU\3\2\2\2U\\\3\2\2\2VX\7")
          buf.write(u"\22\2\2WY\5\n\6\2XW\3\2\2\2XY\3\2\2\2YZ\3\2\2\2Z\\\7")
          buf.write(u"\23\2\2[T\3\2\2\2[V\3\2\2\2\\\t\3\2\2\2]b\5\f\7\2^_\7")
          buf.write(u"\31\2\2_a\5\f\7\2`^\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc\3\2")
          buf.write(u"\2\2c\13\3\2\2\2db\3\2\2\2eh\7Q\2\2fg\7#\2\2gi\5*\26")
          buf.write(u"\2hf\3\2\2\2hi\3\2\2\2i\r\3\2\2\2jn\7\24\2\2km\5\20\t")
          buf.write(u"\2lk\3\2\2\2mp\3\2\2\2nl\3\2\2\2no\3\2\2\2oq\3\2\2\2")
          buf.write(u"pn\3\2\2\2q{\7\25\2\2rv\7*\2\2su\5\20\t\2ts\3\2\2\2u")
          buf.write(u"x\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2\2\2y{\7")
          buf.write(u"+\2\2zj\3\2\2\2zr\3\2\2\2{\17\3\2\2\2|}\5\22\n\2}\21")
          buf.write(u"\3\2\2\2~\u00a5\5\16\b\2\177\u00a5\5\24\13\2\u0080\u00a5")
          buf.write(u"\5\26\f\2\u0081\u0083\5\30\r\2\u0082\u0084\7\30\2\2\u0083")
          buf.write(u"\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u00a5\3\2\2")
          buf.write(u"\2\u0085\u0087\7\17\2\2\u0086\u0088\5*\26\2\u0087\u0086")
          buf.write(u"\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u008a\3\2\2\2\u0089")
          buf.write(u"\u008b\7\30\2\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2")
          buf.write(u"\2\u008b\u00a5\3\2\2\2\u008c\u008e\7\20\2\2\u008d\u008f")
          buf.write(u"\7\30\2\2\u008e\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f")
          buf.write(u"\u00a5\3\2\2\2\u0090\u0092\7\21\2\2\u0091\u0093\7\30")
          buf.write(u"\2\2\u0092\u0091\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u00a5")
          buf.write(u"\3\2\2\2\u0094\u0096\5\32\16\2\u0095\u0097\7\30\2\2\u0096")
          buf.write(u"\u0095\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u00a5\3\2\2")
          buf.write(u"\2\u0098\u009a\5\34\17\2\u0099\u009b\7\30\2\2\u009a\u0099")
          buf.write(u"\3\2\2\2\u009a\u009b\3\2\2\2\u009b\u00a5\3\2\2\2\u009c")
          buf.write(u"\u009e\5\36\20\2\u009d\u009f\7\30\2\2\u009e\u009d\3\2")
          buf.write(u"\2\2\u009e\u009f\3\2\2\2\u009f\u00a5\3\2\2\2\u00a0\u00a2")
          buf.write(u"\5 \21\2\u00a1\u00a3\7\30\2\2\u00a2\u00a1\3\2\2\2\u00a2")
          buf.write(u"\u00a3\3\2\2\2\u00a3\u00a5\3\2\2\2\u00a4~\3\2\2\2\u00a4")
          buf.write(u"\177\3\2\2\2\u00a4\u0080\3\2\2\2\u00a4\u0081\3\2\2\2")
          buf.write(u"\u00a4\u0085\3\2\2\2\u00a4\u008c\3\2\2\2\u00a4\u0090")
          buf.write(u"\3\2\2\2\u00a4\u0094\3\2\2\2\u00a4\u0098\3\2\2\2\u00a4")
          buf.write(u"\u009c\3\2\2\2\u00a4\u00a0\3\2\2\2\u00a5\23\3\2\2\2\u00a6")
          buf.write(u"\u00a7\7\f\2\2\u00a7\u00a8\5&\24\2\u00a8\u00a9\5\22\n")
          buf.write(u"\2\u00a9\u00b1\3\2\2\2\u00aa\u00ab\7\f\2\2\u00ab\u00ac")
          buf.write(u"\7\22\2\2\u00ac\u00ad\5&\24\2\u00ad\u00ae\7\23\2\2\u00ae")
          buf.write(u"\u00af\5\22\n\2\u00af\u00b1\3\2\2\2\u00b0\u00a6\3\2\2")
          buf.write(u"\2\u00b0\u00aa\3\2\2\2\u00b1\25\3\2\2\2\u00b2\u00b3\7")
          buf.write(u"\16\2\2\u00b3\u00b4\5$\23\2\u00b4\u00b7\5\22\n\2\u00b5")
          buf.write(u"\u00b6\7\3\2\2\u00b6\u00b8\5\22\n\2\u00b7\u00b5\3\2\2")
          buf.write(u"\2\u00b7\u00b8\3\2\2\2\u00b8\27\3\2\2\2\u00b9\u00ba\5")
          buf.write(u"*\26\2\u00ba\31\3\2\2\2\u00bb\u00bd\7\r\2\2\u00bc\u00be")
          buf.write(u"\5*\26\2\u00bd\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be")
          buf.write(u"\u00c3\3\2\2\2\u00bf\u00c0\7\31\2\2\u00c0\u00c2\5*\26")
          buf.write(u"\2\u00c1\u00bf\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3\u00c1")
          buf.write(u"\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\33\3\2\2\2\u00c5\u00c3")
          buf.write(u"\3\2\2\2\u00c6\u00c8\7\4\2\2\u00c7\u00c9\5*\26\2\u00c8")
          buf.write(u"\u00c7\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\35\3\2\2\2\u00ca")
          buf.write(u"\u00cb\7$\2\2\u00cb\u00cd\7$\2\2\u00cc\u00ce\5*\26\2")
          buf.write(u"\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d3")
          buf.write(u"\3\2\2\2\u00cf\u00d0\7\31\2\2\u00d0\u00d2\5*\26\2\u00d1")
          buf.write(u"\u00cf\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d1\3\2\2")
          buf.write(u"\2\u00d3\u00d4\3\2\2\2\u00d4\37\3\2\2\2\u00d5\u00d3\3")
          buf.write(u"\2\2\2\u00d6\u00d7\t\2\2\2\u00d7!\3\2\2\2\u00d8\u00dd")
          buf.write(u"\5*\26\2\u00d9\u00da\7\31\2\2\u00da\u00dc\5*\26\2\u00db")
          buf.write(u"\u00d9\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00db\3\2\2")
          buf.write(u"\2\u00dd\u00de\3\2\2\2\u00de#\3\2\2\2\u00df\u00dd\3\2")
          buf.write(u"\2\2\u00e0\u00e6\5*\26\2\u00e1\u00e2\7\22\2\2\u00e2\u00e3")
          buf.write(u"\5*\26\2\u00e3\u00e4\7\23\2\2\u00e4\u00e6\3\2\2\2\u00e5")
          buf.write(u"\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e6%\3\2\2\2\u00e7")
          buf.write(u"\u00e8\7Q\2\2\u00e8\u00e9\7\31\2\2\u00e9\u00ea\5(\25")
          buf.write(u"\2\u00ea\'\3\2\2\2\u00eb\u00ec\5*\26\2\u00ec)\3\2\2\2")
          buf.write(u"\u00ed\u00ee\b\26\1\2\u00ee\u00ef\t\3\2\2\u00ef\u00f6")
          buf.write(u"\5*\26\5\u00f0\u00f1\t\4\2\2\u00f1\u00f6\5*\26\4\u00f2")
          buf.write(u"\u00f3\7\'\2\2\u00f3\u00f6\5*\26\3\u00f4\u00f6\5\62\32")
          buf.write(u"\2\u00f5\u00ed\3\2\2\2\u00f5\u00f0\3\2\2\2\u00f5\u00f2")
          buf.write(u"\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u0111\3\2\2\2\u00f7")
          buf.write(u"\u00f8\f\13\2\2\u00f8\u00f9\t\5\2\2\u00f9\u0110\5*\26")
          buf.write(u"\f\u00fa\u00fb\f\n\2\2\u00fb\u00fc\t\6\2\2\u00fc\u0110")
          buf.write(u"\5*\26\13\u00fd\u00fe\f\t\2\2\u00fe\u00ff\t\7\2\2\u00ff")
          buf.write(u"\u0110\5*\26\n\u0100\u0101\f\b\2\2\u0101\u0102\t\b\2")
          buf.write(u"\2\u0102\u0110\5*\26\t\u0103\u0104\f\7\2\2\u0104\u0105")
          buf.write(u"\t\t\2\2\u0105\u0110\5*\26\b\u0106\u0107\f\6\2\2\u0107")
          buf.write(u"\u0108\t\n\2\2\u0108\u0110\5*\26\7\u0109\u010a\f\f\2")
          buf.write(u"\2\u010a\u010c\7\22\2\2\u010b\u010d\5\"\22\2\u010c\u010b")
          buf.write(u"\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010e\3\2\2\2\u010e")
          buf.write(u"\u0110\7\23\2\2\u010f\u00f7\3\2\2\2\u010f\u00fa\3\2\2")
          buf.write(u"\2\u010f\u00fd\3\2\2\2\u010f\u0100\3\2\2\2\u010f\u0103")
          buf.write(u"\3\2\2\2\u010f\u0106\3\2\2\2\u010f\u0109\3\2\2\2\u0110")
          buf.write(u"\u0113\3\2\2\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2")
          buf.write(u"\2\u0112+\3\2\2\2\u0113\u0111\3\2\2\2\u0114\u0115\7\24")
          buf.write(u"\2\2\u0115\u0116\5.\30\2\u0116\u0117\7\25\2\2\u0117-")
          buf.write(u"\3\2\2\2\u0118\u011a\7H\2\2\u0119\u0118\3\2\2\2\u0119")
          buf.write(u"\u011a\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u0124\5\60\31")
          buf.write(u"\2\u011c\u011e\7H\2\2\u011d\u011c\3\2\2\2\u011d\u011e")
          buf.write(u"\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0120\5\60\31\2\u0120")
          buf.write(u"\u0121\7;\2\2\u0121\u0122\5\60\31\2\u0122\u0124\3\2\2")
          buf.write(u"\2\u0123\u0119\3\2\2\2\u0123\u011d\3\2\2\2\u0124/\3\2")
          buf.write(u"\2\2\u0125\u012a\7Q\2\2\u0126\u0127\7Q\2\2\u0127\u0128")
          buf.write(u"\7\60\2\2\u0128\u012a\7Q\2\2\u0129\u0125\3\2\2\2\u0129")
          buf.write(u"\u0126\3\2\2\2\u012a\61\3\2\2\2\u012b\u012d\7Q\2\2\u012c")
          buf.write(u"\u012e\5,\27\2\u012d\u012c\3\2\2\2\u012d\u012e\3\2\2")
          buf.write(u"\2\u012e\u0149\3\2\2\2\u012f\u0131\5\64\33\2\u0130\u0132")
          buf.write(u"\5,\27\2\u0131\u0130\3\2\2\2\u0131\u0132\3\2\2\2\u0132")
          buf.write(u"\u0149\3\2\2\2\u0133\u0134\7\22\2\2\u0134\u0135\5*\26")
          buf.write(u"\2\u0135\u0137\7\23\2\2\u0136\u0138\5,\27\2\u0137\u0136")
          buf.write(u"\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u0149\3\2\2\2\u0139")
          buf.write(u"\u013b\7\26\2\2\u013a\u013c\5*\26\2\u013b\u013a\3\2\2")
          buf.write(u"\2\u013b\u013c\3\2\2\2\u013c\u0141\3\2\2\2\u013d\u013e")
          buf.write(u"\7\31\2\2\u013e\u0140\5*\26\2\u013f\u013d\3\2\2\2\u0140")
          buf.write(u"\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141\u0142\3\2\2")
          buf.write(u"\2\u0142\u0144\3\2\2\2\u0143\u0141\3\2\2\2\u0144\u0146")
          buf.write(u"\7\27\2\2\u0145\u0147\5,\27\2\u0146\u0145\3\2\2\2\u0146")
          buf.write(u"\u0147\3\2\2\2\u0147\u0149\3\2\2\2\u0148\u012b\3\2\2")
          buf.write(u"\2\u0148\u012f\3\2\2\2\u0148\u0133\3\2\2\2\u0148\u0139")
          buf.write(u"\3\2\2\2\u0149\63\3\2\2\2\u014a\u014f\5:\36\2\u014b\u014f")
          buf.write(u"\5\66\34\2\u014c\u014f\5> \2\u014d\u014f\5@!\2\u014e")
          buf.write(u"\u014a\3\2\2\2\u014e\u014b\3\2\2\2\u014e\u014c\3\2\2")
          buf.write(u"\2\u014e\u014d\3\2\2\2\u014f\65\3\2\2\2\u0150\u0154\7")
          buf.write(u"I\2\2\u0151\u0154\7J\2\2\u0152\u0154\58\35\2\u0153\u0150")
          buf.write(u"\3\2\2\2\u0153\u0151\3\2\2\2\u0153\u0152\3\2\2\2\u0154")
          buf.write(u"\67\3\2\2\2\u0155\u0159\7\5\2\2\u0156\u0158\n\13\2\2")
          buf.write(u"\u0157\u0156\3\2\2\2\u0158\u015b\3\2\2\2\u0159\u0157")
          buf.write(u"\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u0164\3\2\2\2\u015b")
          buf.write(u"\u0159\3\2\2\2\u015c\u0160\7\7\2\2\u015d\u015f\n\13\2")
          buf.write(u"\2\u015e\u015d\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e")
          buf.write(u"\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0164\3\2\2\2\u0162")
          buf.write(u"\u0160\3\2\2\2\u0163\u0155\3\2\2\2\u0163\u015c\3\2\2")
          buf.write(u"\2\u01649\3\2\2\2\u0165\u0169\5<\37\2\u0166\u0169\7O")
          buf.write(u"\2\2\u0167\u0169\7P\2\2\u0168\u0165\3\2\2\2\u0168\u0166")
          buf.write(u"\3\2\2\2\u0168\u0167\3\2\2\2\u0169;\3\2\2\2\u016a\u016b")
          buf.write(u"\t\f\2\2\u016b=\3\2\2\2\u016c\u016d\t\r\2\2\u016d?\3")
          buf.write(u"\2\2\2\u016e\u016f\7\n\2\2\u016fA\3\2\2\2\64ELTX[bhn")
          buf.write(u"vz\u0083\u0087\u008a\u008e\u0092\u0096\u009a\u009e\u00a2")
          buf.write(u"\u00a4\u00b0\u00b7\u00bd\u00c3\u00c8\u00cd\u00d3\u00dd")
          buf.write(u"\u00e5\u00f5\u010c\u010f\u0111\u0119\u011d\u0123\u0129")
          buf.write(u"\u012d\u0131\u0137\u013b\u0141\u0146\u0148\u014e\u0153")
          buf.write(u"\u0159\u0160\u0163\u0168")
          return buf.getvalue()
  
  
  class UnitXParser ( Parser ):
  
      grammarFileName = "UnitX.g4"
  
      atn = ATNDeserializer().deserialize(serializedATN())
  
      decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
  
      sharedContextCache = PredictionContextCache()
  
      literalNames = [ u"<INVALID>", u"'else'", u"'assert'", u"'\"\"\"'", 
                       u"'\r'", u"'''''", u"'true'", u"'false'", u"'NULL'", 
                       u"'def'", u"'rep'", u"'print'", u"'if'", u"'return'", 
                       u"'break'", u"'continue'", u"'('", u"')'", u"'{'", 
                       u"'}'", u"'['", u"']'", u"';'", u"','", u"'.'", u"'---'", 
                       u"'----'", u"'-----'", u"'------'", u"'-------'", u"'--------'", 
                       u"'---------'", u"'----------'", u"'='", u"'>'", u"'<'", 
                       u"'!'", u"'not'", u"'~'", u"'?'", u"':'", u"'end'", 
                       u"'=='", u"'is'", u"'<='", u"'>='", u"'->'", u"'!='", 
                       u"'&&'", u"'||'", u"'and'", u"'or'", u"'++'", u"'--'", 
                       u"'+'", u"'-'", u"'*'", u"'/'", u"'&'", u"'|'", u"'^'", 
                       u"'%'", u"'+='", u"'-='", u"'*='", u"'/='", u"'&='", 
                       u"'|='", u"'^='", u"'%='", u"'@'", u"<INVALID>", u"<INVALID>", 
                       u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                       u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'\n'" ]
  
      symbolicNames = [ u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                        u"<INVALID>", u"DEF", u"REP", u"PRINT", u"IF", u"RETURN", 
                        u"BREAK", u"CONTINUE", u"LPAREN", u"RPAREN", u"LBRACE", 
                        u"RBRACE", u"LBRACK", u"RBRACK", u"SEMICOLON", u"COMMA", 
                        u"DOT", u"THREE_BORDER", u"FOUR_BORDER", u"FIVE_BORDER", 
                        u"SIX_BORDER", u"SEVEN_BORDER", u"EIGHT_BORDER", u"NINE_BORDER", 
                        u"TEN_BORDER", u"ASSIGN", u"GT", u"LT", u"BANG", u"BANG_X", 
                        u"TILDE", u"QUESTION", u"COLON", u"END", u"EQUAL", 
                        u"EQUAL_X", u"LE", u"GE", u"ALLOW", u"NOTEQUAL", u"AND", 
                        u"OR", u"AND_X", u"OR_X", u"INC", u"DEC", u"ADD", 
                        u"SUB", u"MUL", u"DIV", u"BITAND", u"BITOR", u"CARET", 
                        u"MOD", u"ADD_ASSIGN", u"SUB_ASSIGN", u"MUL_ASSIGN", 
                        u"DIV_ASSIGN", u"AND_ASSIGN", u"OR_ASSIGN", u"XOR_ASSIGN", 
                        u"MOD_ASSIGN", u"AT", u"STRING_LITERAL", u"BYTES_LITERAL", 
                        u"DECIMAL_INTEGER", u"OCT_INTEGER", u"HEX_INTEGER", 
                        u"BIN_INTEGER", u"FLOAT_NUMBER", u"IMAG_NUMBER", u"Identifier", 
                        u"NEWLINE", u"WS", u"COMMENT", u"LINE_COMMENT", u"C_LINE_COMMENT" ]
  
      RULE_program = 0
      RULE_typeDeclaration = 1
      RULE_functionDeclaration = 2
      RULE_formalParameters = 3
      RULE_formalParameterList = 4
      RULE_formalParameter = 5
      RULE_block = 6
      RULE_blockStatement = 7
      RULE_statement = 8
      RULE_repStatement = 9
      RULE_ifStatement = 10
      RULE_expressionStatement = 11
      RULE_printStatement = 12
      RULE_assertStatement = 13
      RULE_dumpStatement = 14
      RULE_borderStatement = 15
      RULE_expressionList = 16
      RULE_parExpression = 17
      RULE_repControl = 18
      RULE_endRep = 19
      RULE_expression = 20
      RULE_unit = 21
      RULE_unitSingleOrPairOperator = 22
      RULE_unitOperator = 23
      RULE_primary = 24
      RULE_literal = 25
      RULE_string = 26
      RULE_halfString = 27
      RULE_number = 28
      RULE_integer = 29
      RULE_boolean = 30
      RULE_none = 31
  
      ruleNames =  [ u"program", u"typeDeclaration", u"functionDeclaration", 
                     u"formalParameters", u"formalParameterList", u"formalParameter", 
                     u"block", u"blockStatement", u"statement", u"repStatement", 
                     u"ifStatement", u"expressionStatement", u"printStatement", 
                     u"assertStatement", u"dumpStatement", u"borderStatement", 
                     u"expressionList", u"parExpression", u"repControl", u"endRep", 
                     u"expression", u"unit", u"unitSingleOrPairOperator", 
                     u"unitOperator", u"primary", u"literal", u"string", u"halfString", 
                     u"number", u"integer", u"boolean", u"none" ]
  
      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
      DEF=9
      REP=10
      PRINT=11
      IF=12
      RETURN=13
      BREAK=14
      CONTINUE=15
      LPAREN=16
      RPAREN=17
      LBRACE=18
      RBRACE=19
      LBRACK=20
      RBRACK=21
      SEMICOLON=22
      COMMA=23
      DOT=24
      THREE_BORDER=25
      FOUR_BORDER=26
      FIVE_BORDER=27
      SIX_BORDER=28
      SEVEN_BORDER=29
      EIGHT_BORDER=30
      NINE_BORDER=31
      TEN_BORDER=32
      ASSIGN=33
      GT=34
      LT=35
      BANG=36
      BANG_X=37
      TILDE=38
      QUESTION=39
      COLON=40
      END=41
      EQUAL=42
      EQUAL_X=43
      LE=44
      GE=45
      ALLOW=46
      NOTEQUAL=47
      AND=48
      OR=49
      AND_X=50
      OR_X=51
      INC=52
      DEC=53
      ADD=54
      SUB=55
      MUL=56
      DIV=57
      BITAND=58
      BITOR=59
      CARET=60
      MOD=61
      ADD_ASSIGN=62
      SUB_ASSIGN=63
      MUL_ASSIGN=64
      DIV_ASSIGN=65
      AND_ASSIGN=66
      OR_ASSIGN=67
      XOR_ASSIGN=68
      MOD_ASSIGN=69
      AT=70
      STRING_LITERAL=71
      BYTES_LITERAL=72
      DECIMAL_INTEGER=73
      OCT_INTEGER=74
      HEX_INTEGER=75
      BIN_INTEGER=76
      FLOAT_NUMBER=77
      IMAG_NUMBER=78
      Identifier=79
      NEWLINE=80
      WS=81
      COMMENT=82
      LINE_COMMENT=83
      C_LINE_COMMENT=84
  
      def __init__(self, input):
          super(UnitXParser, self).__init__(input)
          self.checkVersion("4.5.1")
          self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
          self._predicates = None
  
  
  
      class ProgramContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.ProgramContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def EOF(self):
              return self.getToken(UnitXParser.EOF, 0)
  
          def typeDeclaration(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.TypeDeclarationContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.TypeDeclarationContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_program
  
          def enterRule(self, listener):
              if hasattr(listener, "enterProgram"):
                  listener.enterProgram(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitProgram"):
                  listener.exitProgram(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitProgram"):
                  return visitor.visitProgram(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def program(self):
  
          localctx = UnitXParser.ProgramContext(self, self._ctx, self.state)
          self.enterRule(localctx, 0, self.RULE_program)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 67
              self._errHandler.sync(self)
              _la = self._input.LA(1)
              while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.T__1) | (1 << UnitXParser.T__2) | (1 << UnitXParser.T__4) | (1 << UnitXParser.T__5) | (1 << UnitXParser.T__6) | (1 << UnitXParser.T__7) | (1 << UnitXParser.DEF) | (1 << UnitXParser.REP) | (1 << UnitXParser.PRINT) | (1 << UnitXParser.IF) | (1 << UnitXParser.RETURN) | (1 << UnitXParser.BREAK) | (1 << UnitXParser.CONTINUE) | (1 << UnitXParser.LPAREN) | (1 << UnitXParser.LBRACE) | (1 << UnitXParser.LBRACK) | (1 << UnitXParser.THREE_BORDER) | (1 << UnitXParser.FOUR_BORDER) | (1 << UnitXParser.FIVE_BORDER) | (1 << UnitXParser.SIX_BORDER) | (1 << UnitXParser.SEVEN_BORDER) | (1 << UnitXParser.EIGHT_BORDER) | (1 << UnitXParser.NINE_BORDER) | (1 << UnitXParser.TEN_BORDER) | (1 << UnitXParser.GT) | (1 << UnitXParser.BANG) | (1 << UnitXParser.BANG_X) | (1 << UnitXParser.COLON) | (1 << UnitXParser.INC) | (1 << UnitXParser.DEC))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (UnitXParser.STRING_LITERAL - 71)) | (1 << (UnitXParser.BYTES_LITERAL - 71)) | (1 << (UnitXParser.DECIMAL_INTEGER - 71)) | (1 << (UnitXParser.OCT_INTEGER - 71)) | (1 << (UnitXParser.HEX_INTEGER - 71)) | (1 << (UnitXParser.BIN_INTEGER - 71)) | (1 << (UnitXParser.FLOAT_NUMBER - 71)) | (1 << (UnitXParser.IMAG_NUMBER - 71)) | (1 << (UnitXParser.Identifier - 71)))) != 0):
                  self.state = 64
                  self.typeDeclaration()
                  self.state = 69
                  self._errHandler.sync(self)
                  _la = self._input.LA(1)
  
              self.state = 70
              self.match(UnitXParser.EOF)
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class TypeDeclarationContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.TypeDeclarationContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def statement(self):
              return self.getTypedRuleContext(UnitXParser.StatementContext,0)
  
  
          def functionDeclaration(self):
              return self.getTypedRuleContext(UnitXParser.FunctionDeclarationContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_typeDeclaration
  
          def enterRule(self, listener):
              if hasattr(listener, "enterTypeDeclaration"):
                  listener.enterTypeDeclaration(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitTypeDeclaration"):
                  listener.exitTypeDeclaration(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitTypeDeclaration"):
                  return visitor.visitTypeDeclaration(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def typeDeclaration(self):
  
          localctx = UnitXParser.TypeDeclarationContext(self, self._ctx, self.state)
          self.enterRule(localctx, 2, self.RULE_typeDeclaration)
          try:
              self.state = 74
              token = self._input.LA(1)
              if token in [UnitXParser.T__1, UnitXParser.T__2, UnitXParser.T__4, UnitXParser.T__5, UnitXParser.T__6, UnitXParser.T__7, UnitXParser.REP, UnitXParser.PRINT, UnitXParser.IF, UnitXParser.RETURN, UnitXParser.BREAK, UnitXParser.CONTINUE, UnitXParser.LPAREN, UnitXParser.LBRACE, UnitXParser.LBRACK, UnitXParser.THREE_BORDER, UnitXParser.FOUR_BORDER, UnitXParser.FIVE_BORDER, UnitXParser.SIX_BORDER, UnitXParser.SEVEN_BORDER, UnitXParser.EIGHT_BORDER, UnitXParser.NINE_BORDER, UnitXParser.TEN_BORDER, UnitXParser.GT, UnitXParser.BANG, UnitXParser.BANG_X, UnitXParser.COLON, UnitXParser.INC, UnitXParser.DEC, UnitXParser.STRING_LITERAL, UnitXParser.BYTES_LITERAL, UnitXParser.DECIMAL_INTEGER, UnitXParser.OCT_INTEGER, UnitXParser.HEX_INTEGER, UnitXParser.BIN_INTEGER, UnitXParser.FLOAT_NUMBER, UnitXParser.IMAG_NUMBER, UnitXParser.Identifier]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 72
                  self.statement()
  
              elif token in [UnitXParser.DEF]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 73
                  self.functionDeclaration()
  
              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 FunctionDeclarationContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.FunctionDeclarationContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def Identifier(self):
              return self.getToken(UnitXParser.Identifier, 0)
  
          def formalParameters(self):
              return self.getTypedRuleContext(UnitXParser.FormalParametersContext,0)
  
  
          def block(self):
              return self.getTypedRuleContext(UnitXParser.BlockContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_functionDeclaration
  
          def enterRule(self, listener):
              if hasattr(listener, "enterFunctionDeclaration"):
                  listener.enterFunctionDeclaration(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitFunctionDeclaration"):
                  listener.exitFunctionDeclaration(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitFunctionDeclaration"):
                  return visitor.visitFunctionDeclaration(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def functionDeclaration(self):
  
          localctx = UnitXParser.FunctionDeclarationContext(self, self._ctx, self.state)
          self.enterRule(localctx, 4, self.RULE_functionDeclaration)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 76
              self.match(UnitXParser.DEF)
              self.state = 77
              self.match(UnitXParser.Identifier)
              self.state = 78
              self.formalParameters()
              self.state = 79
              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 FormalParametersContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.FormalParametersContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def formalParameterList(self):
              return self.getTypedRuleContext(UnitXParser.FormalParameterListContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_formalParameters
  
          def enterRule(self, listener):
              if hasattr(listener, "enterFormalParameters"):
                  listener.enterFormalParameters(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitFormalParameters"):
                  listener.exitFormalParameters(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitFormalParameters"):
                  return visitor.visitFormalParameters(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def formalParameters(self):
  
          localctx = UnitXParser.FormalParametersContext(self, self._ctx, self.state)
          self.enterRule(localctx, 6, self.RULE_formalParameters)
          self._la = 0 # Token type
          try:
              self.state = 89
              token = self._input.LA(1)
              if token in [UnitXParser.LBRACE, UnitXParser.COLON, UnitXParser.Identifier]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 82
                  _la = self._input.LA(1)
                  if _la==UnitXParser.Identifier:
                      self.state = 81
                      self.formalParameterList()
  
  
  
              elif token in [UnitXParser.LPAREN]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 84
                  self.match(UnitXParser.LPAREN)
                  self.state = 86
                  _la = self._input.LA(1)
                  if _la==UnitXParser.Identifier:
                      self.state = 85
                      self.formalParameterList()
  
  
                  self.state = 88
                  self.match(UnitXParser.RPAREN)
  
              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 FormalParameterListContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.FormalParameterListContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def formalParameter(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.FormalParameterContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.FormalParameterContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_formalParameterList
  
          def enterRule(self, listener):
              if hasattr(listener, "enterFormalParameterList"):
                  listener.enterFormalParameterList(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitFormalParameterList"):
                  listener.exitFormalParameterList(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitFormalParameterList"):
                  return visitor.visitFormalParameterList(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def formalParameterList(self):
  
          localctx = UnitXParser.FormalParameterListContext(self, self._ctx, self.state)
          self.enterRule(localctx, 8, self.RULE_formalParameterList)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 91
              self.formalParameter()
              self.state = 96
              self._errHandler.sync(self)
              _la = self._input.LA(1)
              while _la==UnitXParser.COMMA:
                  self.state = 92
                  self.match(UnitXParser.COMMA)
                  self.state = 93
                  self.formalParameter()
                  self.state = 98
                  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 FormalParameterContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.FormalParameterContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def Identifier(self):
              return self.getToken(UnitXParser.Identifier, 0)
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_formalParameter
  
          def enterRule(self, listener):
              if hasattr(listener, "enterFormalParameter"):
                  listener.enterFormalParameter(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitFormalParameter"):
                  listener.exitFormalParameter(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitFormalParameter"):
                  return visitor.visitFormalParameter(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def formalParameter(self):
  
          localctx = UnitXParser.FormalParameterContext(self, self._ctx, self.state)
          self.enterRule(localctx, 10, self.RULE_formalParameter)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 99
              self.match(UnitXParser.Identifier)
              self.state = 102
              _la = self._input.LA(1)
              if _la==UnitXParser.ASSIGN:
                  self.state = 100
                  self.match(UnitXParser.ASSIGN)
                  self.state = 101
                  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 BlockContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.BlockContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def blockStatement(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.BlockStatementContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.BlockStatementContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_block
  
          def enterRule(self, listener):
              if hasattr(listener, "enterBlock"):
                  listener.enterBlock(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitBlock"):
                  listener.exitBlock(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitBlock"):
                  return visitor.visitBlock(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def block(self):
  
          localctx = UnitXParser.BlockContext(self, self._ctx, self.state)
          self.enterRule(localctx, 12, self.RULE_block)
          self._la = 0 # Token type
          try:
              self.state = 120
              token = self._input.LA(1)
              if token in [UnitXParser.LBRACE]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 104
                  self.match(UnitXParser.LBRACE)
                  self.state = 108
                  self._errHandler.sync(self)
                  _la = self._input.LA(1)
                  while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.T__1) | (1 << UnitXParser.T__2) | (1 << UnitXParser.T__4) | (1 << UnitXParser.T__5) | (1 << UnitXParser.T__6) | (1 << UnitXParser.T__7) | (1 << UnitXParser.REP) | (1 << UnitXParser.PRINT) | (1 << UnitXParser.IF) | (1 << UnitXParser.RETURN) | (1 << UnitXParser.BREAK) | (1 << UnitXParser.CONTINUE) | (1 << UnitXParser.LPAREN) | (1 << UnitXParser.LBRACE) | (1 << UnitXParser.LBRACK) | (1 << UnitXParser.THREE_BORDER) | (1 << UnitXParser.FOUR_BORDER) | (1 << UnitXParser.FIVE_BORDER) | (1 << UnitXParser.SIX_BORDER) | (1 << UnitXParser.SEVEN_BORDER) | (1 << UnitXParser.EIGHT_BORDER) | (1 << UnitXParser.NINE_BORDER) | (1 << UnitXParser.TEN_BORDER) | (1 << UnitXParser.GT) | (1 << UnitXParser.BANG) | (1 << UnitXParser.BANG_X) | (1 << UnitXParser.COLON) | (1 << UnitXParser.INC) | (1 << UnitXParser.DEC))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (UnitXParser.STRING_LITERAL - 71)) | (1 << (UnitXParser.BYTES_LITERAL - 71)) | (1 << (UnitXParser.DECIMAL_INTEGER - 71)) | (1 << (UnitXParser.OCT_INTEGER - 71)) | (1 << (UnitXParser.HEX_INTEGER - 71)) | (1 << (UnitXParser.BIN_INTEGER - 71)) | (1 << (UnitXParser.FLOAT_NUMBER - 71)) | (1 << (UnitXParser.IMAG_NUMBER - 71)) | (1 << (UnitXParser.Identifier - 71)))) != 0):
                      self.state = 105
                      self.blockStatement()
                      self.state = 110
                      self._errHandler.sync(self)
                      _la = self._input.LA(1)
  
                  self.state = 111
                  self.match(UnitXParser.RBRACE)
  
              elif token in [UnitXParser.COLON]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 112
                  self.match(UnitXParser.COLON)
                  self.state = 116
                  self._errHandler.sync(self)
                  _la = self._input.LA(1)
                  while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.T__1) | (1 << UnitXParser.T__2) | (1 << UnitXParser.T__4) | (1 << UnitXParser.T__5) | (1 << UnitXParser.T__6) | (1 << UnitXParser.T__7) | (1 << UnitXParser.REP) | (1 << UnitXParser.PRINT) | (1 << UnitXParser.IF) | (1 << UnitXParser.RETURN) | (1 << UnitXParser.BREAK) | (1 << UnitXParser.CONTINUE) | (1 << UnitXParser.LPAREN) | (1 << UnitXParser.LBRACE) | (1 << UnitXParser.LBRACK) | (1 << UnitXParser.THREE_BORDER) | (1 << UnitXParser.FOUR_BORDER) | (1 << UnitXParser.FIVE_BORDER) | (1 << UnitXParser.SIX_BORDER) | (1 << UnitXParser.SEVEN_BORDER) | (1 << UnitXParser.EIGHT_BORDER) | (1 << UnitXParser.NINE_BORDER) | (1 << UnitXParser.TEN_BORDER) | (1 << UnitXParser.GT) | (1 << UnitXParser.BANG) | (1 << UnitXParser.BANG_X) | (1 << UnitXParser.COLON) | (1 << UnitXParser.INC) | (1 << UnitXParser.DEC))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (UnitXParser.STRING_LITERAL - 71)) | (1 << (UnitXParser.BYTES_LITERAL - 71)) | (1 << (UnitXParser.DECIMAL_INTEGER - 71)) | (1 << (UnitXParser.OCT_INTEGER - 71)) | (1 << (UnitXParser.HEX_INTEGER - 71)) | (1 << (UnitXParser.BIN_INTEGER - 71)) | (1 << (UnitXParser.FLOAT_NUMBER - 71)) | (1 << (UnitXParser.IMAG_NUMBER - 71)) | (1 << (UnitXParser.Identifier - 71)))) != 0):
                      self.state = 113
                      self.blockStatement()
                      self.state = 118
                      self._errHandler.sync(self)
                      _la = self._input.LA(1)
  
                  self.state = 119
                  self.match(UnitXParser.END)
  
              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 BlockStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.BlockStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def statement(self):
              return self.getTypedRuleContext(UnitXParser.StatementContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_blockStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterBlockStatement"):
                  listener.enterBlockStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitBlockStatement"):
                  listener.exitBlockStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitBlockStatement"):
                  return visitor.visitBlockStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def blockStatement(self):
  
          localctx = UnitXParser.BlockStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 14, self.RULE_blockStatement)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 122
              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 StatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.StatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def block(self):
              return self.getTypedRuleContext(UnitXParser.BlockContext,0)
  
  
          def repStatement(self):
              return self.getTypedRuleContext(UnitXParser.RepStatementContext,0)
  
  
          def ifStatement(self):
              return self.getTypedRuleContext(UnitXParser.IfStatementContext,0)
  
  
          def expressionStatement(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionStatementContext,0)
  
  
          def SEMICOLON(self):
              return self.getToken(UnitXParser.SEMICOLON, 0)
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def printStatement(self):
              return self.getTypedRuleContext(UnitXParser.PrintStatementContext,0)
  
  
          def assertStatement(self):
              return self.getTypedRuleContext(UnitXParser.AssertStatementContext,0)
  
  
          def dumpStatement(self):
              return self.getTypedRuleContext(UnitXParser.DumpStatementContext,0)
  
  
          def borderStatement(self):
              return self.getTypedRuleContext(UnitXParser.BorderStatementContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_statement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterStatement"):
                  listener.enterStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitStatement"):
                  listener.exitStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitStatement"):
                  return visitor.visitStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def statement(self):
  
          localctx = UnitXParser.StatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 16, self.RULE_statement)
          self._la = 0 # Token type
          try:
              self.state = 162
              token = self._input.LA(1)
              if token in [UnitXParser.LBRACE, UnitXParser.COLON]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 124
                  self.block()
  
              elif token in [UnitXParser.REP]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 125
                  self.repStatement()
  
              elif token in [UnitXParser.IF]:
                  self.enterOuterAlt(localctx, 3)
                  self.state = 126
                  self.ifStatement()
  
              elif token in [UnitXParser.T__2, UnitXParser.T__4, UnitXParser.T__5, UnitXParser.T__6, UnitXParser.T__7, UnitXParser.LPAREN, UnitXParser.LBRACK, UnitXParser.BANG, UnitXParser.BANG_X, UnitXParser.INC, UnitXParser.DEC, UnitXParser.STRING_LITERAL, UnitXParser.BYTES_LITERAL, UnitXParser.DECIMAL_INTEGER, UnitXParser.OCT_INTEGER, UnitXParser.HEX_INTEGER, UnitXParser.BIN_INTEGER, UnitXParser.FLOAT_NUMBER, UnitXParser.IMAG_NUMBER, UnitXParser.Identifier]:
                  self.enterOuterAlt(localctx, 4)
                  self.state = 127
                  self.expressionStatement()
                  self.state = 129
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 128
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.RETURN]:
                  self.enterOuterAlt(localctx, 5)
                  self.state = 131
                  self.match(UnitXParser.RETURN)
                  self.state = 133
                  la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
                  if la_ == 1:
                      self.state = 132
                      self.expression(0)
  
  
                  self.state = 136
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 135
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.BREAK]:
                  self.enterOuterAlt(localctx, 6)
                  self.state = 138
                  self.match(UnitXParser.BREAK)
                  self.state = 140
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 139
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.CONTINUE]:
                  self.enterOuterAlt(localctx, 7)
                  self.state = 142
                  self.match(UnitXParser.CONTINUE)
                  self.state = 144
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 143
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.PRINT]:
                  self.enterOuterAlt(localctx, 8)
                  self.state = 146
                  self.printStatement()
                  self.state = 148
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 147
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.T__1]:
                  self.enterOuterAlt(localctx, 9)
                  self.state = 150
                  self.assertStatement()
                  self.state = 152
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 151
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.GT]:
                  self.enterOuterAlt(localctx, 10)
                  self.state = 154
                  self.dumpStatement()
                  self.state = 156
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 155
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              elif token in [UnitXParser.THREE_BORDER, UnitXParser.FOUR_BORDER, UnitXParser.FIVE_BORDER, UnitXParser.SIX_BORDER, UnitXParser.SEVEN_BORDER, UnitXParser.EIGHT_BORDER, UnitXParser.NINE_BORDER, UnitXParser.TEN_BORDER]:
                  self.enterOuterAlt(localctx, 11)
                  self.state = 158
                  self.borderStatement()
                  self.state = 160
                  _la = self._input.LA(1)
                  if _la==UnitXParser.SEMICOLON:
                      self.state = 159
                      self.match(UnitXParser.SEMICOLON)
  
  
  
              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 RepStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.RepStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def repControl(self):
              return self.getTypedRuleContext(UnitXParser.RepControlContext,0)
  
  
          def statement(self):
              return self.getTypedRuleContext(UnitXParser.StatementContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_repStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterRepStatement"):
                  listener.enterRepStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitRepStatement"):
                  listener.exitRepStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitRepStatement"):
                  return visitor.visitRepStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def repStatement(self):
  
          localctx = UnitXParser.RepStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 18, self.RULE_repStatement)
          try:
              self.state = 174
              la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
              if la_ == 1:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 164
                  self.match(UnitXParser.REP)
                  self.state = 165
                  self.repControl()
                  self.state = 166
                  self.statement()
                  pass
  
              elif la_ == 2:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 168
                  self.match(UnitXParser.REP)
                  self.state = 169
                  self.match(UnitXParser.LPAREN)
                  self.state = 170
                  self.repControl()
                  self.state = 171
                  self.match(UnitXParser.RPAREN)
                  self.state = 172
                  self.statement()
                  pass
  
  
          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):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.IfStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def parExpression(self):
              return self.getTypedRuleContext(UnitXParser.ParExpressionContext,0)
  
  
          def statement(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.StatementContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.StatementContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_ifStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterIfStatement"):
                  listener.enterIfStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitIfStatement"):
                  listener.exitIfStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitIfStatement"):
                  return visitor.visitIfStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def ifStatement(self):
  
          localctx = UnitXParser.IfStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 20, self.RULE_ifStatement)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 176
              self.match(UnitXParser.IF)
              self.state = 177
              self.parExpression()
              self.state = 178
              self.statement()
              self.state = 181
              la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
              if la_ == 1:
                  self.state = 179
                  self.match(UnitXParser.T__0)
                  self.state = 180
                  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 ExpressionStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.ExpressionStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_expressionStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterExpressionStatement"):
                  listener.enterExpressionStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitExpressionStatement"):
                  listener.exitExpressionStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitExpressionStatement"):
                  return visitor.visitExpressionStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def expressionStatement(self):
  
          localctx = UnitXParser.ExpressionStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 22, self.RULE_expressionStatement)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 183
              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 PrintStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.PrintStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.ExpressionContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.ExpressionContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_printStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterPrintStatement"):
                  listener.enterPrintStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitPrintStatement"):
                  listener.exitPrintStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitPrintStatement"):
                  return visitor.visitPrintStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def printStatement(self):
  
          localctx = UnitXParser.PrintStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 24, self.RULE_printStatement)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 185
              self.match(UnitXParser.PRINT)
              self.state = 187
              la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
              if la_ == 1:
                  self.state = 186
                  self.expression(0)
  
  
              self.state = 193
              self._errHandler.sync(self)
              _la = self._input.LA(1)
              while _la==UnitXParser.COMMA:
                  self.state = 189
                  self.match(UnitXParser.COMMA)
                  self.state = 190
                  self.expression(0)
                  self.state = 195
                  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 AssertStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.AssertStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_assertStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterAssertStatement"):
                  listener.enterAssertStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitAssertStatement"):
                  listener.exitAssertStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitAssertStatement"):
                  return visitor.visitAssertStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def assertStatement(self):
  
          localctx = UnitXParser.AssertStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 26, self.RULE_assertStatement)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 196
              self.match(UnitXParser.T__1)
              self.state = 198
              la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
              if la_ == 1:
                  self.state = 197
                  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 DumpStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.DumpStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.ExpressionContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.ExpressionContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_dumpStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterDumpStatement"):
                  listener.enterDumpStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitDumpStatement"):
                  listener.exitDumpStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitDumpStatement"):
                  return visitor.visitDumpStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def dumpStatement(self):
  
          localctx = UnitXParser.DumpStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 28, self.RULE_dumpStatement)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 200
              self.match(UnitXParser.GT)
              self.state = 201
              self.match(UnitXParser.GT)
              self.state = 203
              la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
              if la_ == 1:
                  self.state = 202
                  self.expression(0)
  
  
              self.state = 209
              self._errHandler.sync(self)
              _la = self._input.LA(1)
              while _la==UnitXParser.COMMA:
                  self.state = 205
                  self.match(UnitXParser.COMMA)
                  self.state = 206
                  self.expression(0)
                  self.state = 211
                  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 BorderStatementContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.BorderStatementContext, self).__init__(parent, invokingState)
              self.parser = parser
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_borderStatement
  
          def enterRule(self, listener):
              if hasattr(listener, "enterBorderStatement"):
                  listener.enterBorderStatement(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitBorderStatement"):
                  listener.exitBorderStatement(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitBorderStatement"):
                  return visitor.visitBorderStatement(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def borderStatement(self):
  
          localctx = UnitXParser.BorderStatementContext(self, self._ctx, self.state)
          self.enterRule(localctx, 30, self.RULE_borderStatement)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 212
              _la = self._input.LA(1)
              if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.THREE_BORDER) | (1 << UnitXParser.FOUR_BORDER) | (1 << UnitXParser.FIVE_BORDER) | (1 << UnitXParser.SIX_BORDER) | (1 << UnitXParser.SEVEN_BORDER) | (1 << UnitXParser.EIGHT_BORDER) | (1 << UnitXParser.NINE_BORDER) | (1 << UnitXParser.TEN_BORDER))) != 0)):
                  self._errHandler.recoverInline(self)
              else:
                  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 ExpressionListContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.ExpressionListContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.ExpressionContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.ExpressionContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_expressionList
  
          def enterRule(self, listener):
              if hasattr(listener, "enterExpressionList"):
                  listener.enterExpressionList(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitExpressionList"):
                  listener.exitExpressionList(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitExpressionList"):
                  return visitor.visitExpressionList(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def expressionList(self):
  
          localctx = UnitXParser.ExpressionListContext(self, self._ctx, self.state)
          self.enterRule(localctx, 32, self.RULE_expressionList)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 214
              self.expression(0)
              self.state = 219
              self._errHandler.sync(self)
              _la = self._input.LA(1)
              while _la==UnitXParser.COMMA:
                  self.state = 215
                  self.match(UnitXParser.COMMA)
                  self.state = 216
                  self.expression(0)
                  self.state = 221
                  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 ParExpressionContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.ParExpressionContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_parExpression
  
          def enterRule(self, listener):
              if hasattr(listener, "enterParExpression"):
                  listener.enterParExpression(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitParExpression"):
                  listener.exitParExpression(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitParExpression"):
                  return visitor.visitParExpression(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def parExpression(self):
  
          localctx = UnitXParser.ParExpressionContext(self, self._ctx, self.state)
          self.enterRule(localctx, 34, self.RULE_parExpression)
          try:
              self.state = 227
              la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
              if la_ == 1:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 222
                  self.expression(0)
                  pass
  
              elif la_ == 2:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 223
                  self.match(UnitXParser.LPAREN)
                  self.state = 224
                  self.expression(0)
                  self.state = 225
                  self.match(UnitXParser.RPAREN)
                  pass
  
  
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class RepControlContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.RepControlContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def Identifier(self):
              return self.getToken(UnitXParser.Identifier, 0)
  
          def endRep(self):
              return self.getTypedRuleContext(UnitXParser.EndRepContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_repControl
  
          def enterRule(self, listener):
              if hasattr(listener, "enterRepControl"):
                  listener.enterRepControl(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitRepControl"):
                  listener.exitRepControl(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitRepControl"):
                  return visitor.visitRepControl(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def repControl(self):
  
          localctx = UnitXParser.RepControlContext(self, self._ctx, self.state)
          self.enterRule(localctx, 36, self.RULE_repControl)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 229
              self.match(UnitXParser.Identifier)
              self.state = 230
              self.match(UnitXParser.COMMA)
              self.state = 231
              self.endRep()
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class EndRepContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.EndRepContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_endRep
  
          def enterRule(self, listener):
              if hasattr(listener, "enterEndRep"):
                  listener.enterEndRep(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitEndRep"):
                  listener.exitEndRep(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitEndRep"):
                  return visitor.visitEndRep(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def endRep(self):
  
          localctx = UnitXParser.EndRepContext(self, self._ctx, self.state)
          self.enterRule(localctx, 38, self.RULE_endRep)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 233
              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 ExpressionContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.ExpressionContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def expression(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.ExpressionContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.ExpressionContext,i)
  
  
          def primary(self):
              return self.getTypedRuleContext(UnitXParser.PrimaryContext,0)
  
  
          def expressionList(self):
              return self.getTypedRuleContext(UnitXParser.ExpressionListContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_expression
  
          def enterRule(self, listener):
              if hasattr(listener, "enterExpression"):
                  listener.enterExpression(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitExpression"):
                  listener.exitExpression(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitExpression"):
                  return visitor.visitExpression(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
      def expression(self, _p=0):
          _parentctx = self._ctx
          _parentState = self.state
          localctx = UnitXParser.ExpressionContext(self, self._ctx, _parentState)
          _prevctx = localctx
          _startState = 40
          self.enterRecursionRule(localctx, 40, self.RULE_expression, _p)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 243
              la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
              if la_ == 1:
                  self.state = 236
                  _la = self._input.LA(1)
                  if not(_la==UnitXParser.INC or _la==UnitXParser.DEC):
                      self._errHandler.recoverInline(self)
                  else:
                      self.consume()
                  self.state = 237
                  self.expression(3)
                  pass
  
              elif la_ == 2:
                  self.state = 238
                  _la = self._input.LA(1)
                  if not(_la==UnitXParser.BANG or _la==UnitXParser.BANG_X):
                      self._errHandler.recoverInline(self)
                  else:
                      self.consume()
                  self.state = 239
                  self.expression(2)
                  pass
  
              elif la_ == 3:
                  self.state = 240
                  self.match(UnitXParser.BANG_X)
                  self.state = 241
                  self.expression(1)
                  pass
  
              elif la_ == 4:
                  self.state = 242
                  self.primary()
                  pass
  
  
              self._ctx.stop = self._input.LT(-1)
              self.state = 271
              self._errHandler.sync(self)
              _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
              while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                  if _alt==1:
                      if self._parseListeners is not None:
                          self.triggerExitRuleEvent()
                      _prevctx = localctx
                      self.state = 269
                      la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                      if la_ == 1:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 245
                          if not self.precpred(self._ctx, 9):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                          self.state = 246
                          _la = self._input.LA(1)
                          if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.MUL) | (1 << UnitXParser.DIV) | (1 << UnitXParser.MOD))) != 0)):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 247
                          self.expression(10)
                          pass
  
                      elif la_ == 2:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 248
                          if not self.precpred(self._ctx, 8):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                          self.state = 249
                          _la = self._input.LA(1)
                          if not(_la==UnitXParser.ADD or _la==UnitXParser.SUB):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 250
                          self.expression(9)
                          pass
  
                      elif la_ == 3:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 251
                          if not self.precpred(self._ctx, 7):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                          self.state = 252
                          _la = self._input.LA(1)
                          if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.GT) | (1 << UnitXParser.LT) | (1 << UnitXParser.LE) | (1 << UnitXParser.GE))) != 0)):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 253
                          self.expression(8)
                          pass
  
                      elif la_ == 4:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 254
                          if not self.precpred(self._ctx, 6):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                          self.state = 255
                          _la = self._input.LA(1)
                          if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.EQUAL) | (1 << UnitXParser.EQUAL_X) | (1 << UnitXParser.NOTEQUAL))) != 0)):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 256
                          self.expression(7)
                          pass
  
                      elif la_ == 5:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 257
                          if not self.precpred(self._ctx, 5):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                          self.state = 258
                          _la = self._input.LA(1)
                          if not(((((_la - 33)) & ~0x3f) == 0 and ((1 << (_la - 33)) & ((1 << (UnitXParser.ASSIGN - 33)) | (1 << (UnitXParser.ADD_ASSIGN - 33)) | (1 << (UnitXParser.SUB_ASSIGN - 33)) | (1 << (UnitXParser.MUL_ASSIGN - 33)) | (1 << (UnitXParser.DIV_ASSIGN - 33)) | (1 << (UnitXParser.MOD_ASSIGN - 33)))) != 0)):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 259
                          self.expression(6)
                          pass
  
                      elif la_ == 6:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 260
                          if not self.precpred(self._ctx, 4):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                          self.state = 261
                          _la = self._input.LA(1)
                          if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.AND) | (1 << UnitXParser.OR) | (1 << UnitXParser.AND_X) | (1 << UnitXParser.OR_X))) != 0)):
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume()
                          self.state = 262
                          self.expression(5)
                          pass
  
                      elif la_ == 7:
                          localctx = UnitXParser.ExpressionContext(self, _parentctx, _parentState)
                          self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                          self.state = 263
                          if not self.precpred(self._ctx, 10):
                              from antlr4.error.Errors import FailedPredicateException
                              raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                          self.state = 264
                          self.match(UnitXParser.LPAREN)
                          self.state = 266
                          _la = self._input.LA(1)
                          if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.T__2) | (1 << UnitXParser.T__4) | (1 << UnitXParser.T__5) | (1 << UnitXParser.T__6) | (1 << UnitXParser.T__7) | (1 << UnitXParser.LPAREN) | (1 << UnitXParser.LBRACK) | (1 << UnitXParser.BANG) | (1 << UnitXParser.BANG_X) | (1 << UnitXParser.INC) | (1 << UnitXParser.DEC))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (UnitXParser.STRING_LITERAL - 71)) | (1 << (UnitXParser.BYTES_LITERAL - 71)) | (1 << (UnitXParser.DECIMAL_INTEGER - 71)) | (1 << (UnitXParser.OCT_INTEGER - 71)) | (1 << (UnitXParser.HEX_INTEGER - 71)) | (1 << (UnitXParser.BIN_INTEGER - 71)) | (1 << (UnitXParser.FLOAT_NUMBER - 71)) | (1 << (UnitXParser.IMAG_NUMBER - 71)) | (1 << (UnitXParser.Identifier - 71)))) != 0):
                              self.state = 265
                              self.expressionList()
  
  
                          self.state = 268
                          self.match(UnitXParser.RPAREN)
                          pass
  
               
                  self.state = 273
                  self._errHandler.sync(self)
                  _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
  
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.unrollRecursionContexts(_parentctx)
          return localctx
  
      class UnitContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.UnitContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def unitSingleOrPairOperator(self):
              return self.getTypedRuleContext(UnitXParser.UnitSingleOrPairOperatorContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_unit
  
          def enterRule(self, listener):
              if hasattr(listener, "enterUnit"):
                  listener.enterUnit(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitUnit"):
                  listener.exitUnit(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitUnit"):
                  return visitor.visitUnit(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def unit(self):
  
          localctx = UnitXParser.UnitContext(self, self._ctx, self.state)
          self.enterRule(localctx, 42, self.RULE_unit)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 274
              self.match(UnitXParser.LBRACE)
              self.state = 275
              self.unitSingleOrPairOperator()
              self.state = 276
              self.match(UnitXParser.RBRACE)
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class UnitSingleOrPairOperatorContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.UnitSingleOrPairOperatorContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def unitOperator(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.UnitOperatorContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.UnitOperatorContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_unitSingleOrPairOperator
  
          def enterRule(self, listener):
              if hasattr(listener, "enterUnitSingleOrPairOperator"):
                  listener.enterUnitSingleOrPairOperator(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitUnitSingleOrPairOperator"):
                  listener.exitUnitSingleOrPairOperator(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitUnitSingleOrPairOperator"):
                  return visitor.visitUnitSingleOrPairOperator(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def unitSingleOrPairOperator(self):
  
          localctx = UnitXParser.UnitSingleOrPairOperatorContext(self, self._ctx, self.state)
          self.enterRule(localctx, 44, self.RULE_unitSingleOrPairOperator)
          self._la = 0 # Token type
          try:
              self.state = 289
              la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
              if la_ == 1:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 279
                  _la = self._input.LA(1)
                  if _la==UnitXParser.AT:
                      self.state = 278
                      self.match(UnitXParser.AT)
  
  
                  self.state = 281
                  self.unitOperator()
                  pass
  
              elif la_ == 2:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 283
                  _la = self._input.LA(1)
                  if _la==UnitXParser.AT:
                      self.state = 282
                      self.match(UnitXParser.AT)
  
  
                  self.state = 285
                  self.unitOperator()
                  self.state = 286
                  self.match(UnitXParser.DIV)
                  self.state = 287
                  self.unitOperator()
                  pass
  
  
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class UnitOperatorContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.UnitOperatorContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def Identifier(self, i=None):
              if i is None:
                  return self.getTokens(UnitXParser.Identifier)
              else:
                  return self.getToken(UnitXParser.Identifier, i)
  
          def getRuleIndex(self):
              return UnitXParser.RULE_unitOperator
  
          def enterRule(self, listener):
              if hasattr(listener, "enterUnitOperator"):
                  listener.enterUnitOperator(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitUnitOperator"):
                  listener.exitUnitOperator(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitUnitOperator"):
                  return visitor.visitUnitOperator(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def unitOperator(self):
  
          localctx = UnitXParser.UnitOperatorContext(self, self._ctx, self.state)
          self.enterRule(localctx, 46, self.RULE_unitOperator)
          try:
              self.state = 295
              la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
              if la_ == 1:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 291
                  self.match(UnitXParser.Identifier)
                  pass
  
              elif la_ == 2:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 292
                  self.match(UnitXParser.Identifier)
                  self.state = 293
                  self.match(UnitXParser.ALLOW)
                  self.state = 294
                  self.match(UnitXParser.Identifier)
                  pass
  
  
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
      class PrimaryContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.PrimaryContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def Identifier(self):
              return self.getToken(UnitXParser.Identifier, 0)
  
          def unit(self):
              return self.getTypedRuleContext(UnitXParser.UnitContext,0)
  
  
          def literal(self):
              return self.getTypedRuleContext(UnitXParser.LiteralContext,0)
  
  
          def expression(self, i=None):
              if i is None:
                  return self.getTypedRuleContexts(UnitXParser.ExpressionContext)
              else:
                  return self.getTypedRuleContext(UnitXParser.ExpressionContext,i)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_primary
  
          def enterRule(self, listener):
              if hasattr(listener, "enterPrimary"):
                  listener.enterPrimary(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitPrimary"):
                  listener.exitPrimary(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitPrimary"):
                  return visitor.visitPrimary(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def primary(self):
  
          localctx = UnitXParser.PrimaryContext(self, self._ctx, self.state)
          self.enterRule(localctx, 48, self.RULE_primary)
          self._la = 0 # Token type
          try:
              self.state = 326
              token = self._input.LA(1)
              if token in [UnitXParser.Identifier]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 297
                  self.match(UnitXParser.Identifier)
                  self.state = 299
                  la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                  if la_ == 1:
                      self.state = 298
                      self.unit()
  
  
  
              elif token in [UnitXParser.T__2, UnitXParser.T__4, UnitXParser.T__5, UnitXParser.T__6, UnitXParser.T__7, UnitXParser.STRING_LITERAL, UnitXParser.BYTES_LITERAL, UnitXParser.DECIMAL_INTEGER, UnitXParser.OCT_INTEGER, UnitXParser.HEX_INTEGER, UnitXParser.BIN_INTEGER, UnitXParser.FLOAT_NUMBER, UnitXParser.IMAG_NUMBER]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 301
                  self.literal()
                  self.state = 303
                  la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                  if la_ == 1:
                      self.state = 302
                      self.unit()
  
  
  
              elif token in [UnitXParser.LPAREN]:
                  self.enterOuterAlt(localctx, 3)
                  self.state = 305
                  self.match(UnitXParser.LPAREN)
                  self.state = 306
                  self.expression(0)
                  self.state = 307
                  self.match(UnitXParser.RPAREN)
                  self.state = 309
                  la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
                  if la_ == 1:
                      self.state = 308
                      self.unit()
  
  
  
              elif token in [UnitXParser.LBRACK]:
                  self.enterOuterAlt(localctx, 4)
                  self.state = 311
                  self.match(UnitXParser.LBRACK)
                  self.state = 313
                  _la = self._input.LA(1)
                  if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UnitXParser.T__2) | (1 << UnitXParser.T__4) | (1 << UnitXParser.T__5) | (1 << UnitXParser.T__6) | (1 << UnitXParser.T__7) | (1 << UnitXParser.LPAREN) | (1 << UnitXParser.LBRACK) | (1 << UnitXParser.BANG) | (1 << UnitXParser.BANG_X) | (1 << UnitXParser.INC) | (1 << UnitXParser.DEC))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (UnitXParser.STRING_LITERAL - 71)) | (1 << (UnitXParser.BYTES_LITERAL - 71)) | (1 << (UnitXParser.DECIMAL_INTEGER - 71)) | (1 << (UnitXParser.OCT_INTEGER - 71)) | (1 << (UnitXParser.HEX_INTEGER - 71)) | (1 << (UnitXParser.BIN_INTEGER - 71)) | (1 << (UnitXParser.FLOAT_NUMBER - 71)) | (1 << (UnitXParser.IMAG_NUMBER - 71)) | (1 << (UnitXParser.Identifier - 71)))) != 0):
                      self.state = 312
                      self.expression(0)
  
  
                  self.state = 319
                  self._errHandler.sync(self)
                  _la = self._input.LA(1)
                  while _la==UnitXParser.COMMA:
                      self.state = 315
                      self.match(UnitXParser.COMMA)
                      self.state = 316
                      self.expression(0)
                      self.state = 321
                      self._errHandler.sync(self)
                      _la = self._input.LA(1)
  
                  self.state = 322
                  self.match(UnitXParser.RBRACK)
                  self.state = 324
                  la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
                  if la_ == 1:
                      self.state = 323
                      self.unit()
  
  
  
              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 LiteralContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.LiteralContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def number(self):
              return self.getTypedRuleContext(UnitXParser.NumberContext,0)
  
  
          def string(self):
              return self.getTypedRuleContext(UnitXParser.StringContext,0)
  
  
          def boolean(self):
              return self.getTypedRuleContext(UnitXParser.BooleanContext,0)
  
  
          def none(self):
              return self.getTypedRuleContext(UnitXParser.NoneContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_literal
  
          def enterRule(self, listener):
              if hasattr(listener, "enterLiteral"):
                  listener.enterLiteral(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitLiteral"):
                  listener.exitLiteral(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitLiteral"):
                  return visitor.visitLiteral(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def literal(self):
  
          localctx = UnitXParser.LiteralContext(self, self._ctx, self.state)
          self.enterRule(localctx, 50, self.RULE_literal)
          try:
              self.state = 332
              token = self._input.LA(1)
              if token in [UnitXParser.DECIMAL_INTEGER, UnitXParser.OCT_INTEGER, UnitXParser.HEX_INTEGER, UnitXParser.BIN_INTEGER, UnitXParser.FLOAT_NUMBER, UnitXParser.IMAG_NUMBER]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 328
                  self.number()
  
              elif token in [UnitXParser.T__2, UnitXParser.T__4, UnitXParser.STRING_LITERAL, UnitXParser.BYTES_LITERAL]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 329
                  self.string()
  
              elif token in [UnitXParser.T__5, UnitXParser.T__6]:
                  self.enterOuterAlt(localctx, 3)
                  self.state = 330
                  self.boolean()
  
              elif token in [UnitXParser.T__7]:
                  self.enterOuterAlt(localctx, 4)
                  self.state = 331
                  self.none()
  
              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 StringContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.StringContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def STRING_LITERAL(self):
              return self.getToken(UnitXParser.STRING_LITERAL, 0)
  
          def BYTES_LITERAL(self):
              return self.getToken(UnitXParser.BYTES_LITERAL, 0)
  
          def halfString(self):
              return self.getTypedRuleContext(UnitXParser.HalfStringContext,0)
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_string
  
          def enterRule(self, listener):
              if hasattr(listener, "enterString"):
                  listener.enterString(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitString"):
                  listener.exitString(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitString"):
                  return visitor.visitString(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def string(self):
  
          localctx = UnitXParser.StringContext(self, self._ctx, self.state)
          self.enterRule(localctx, 52, self.RULE_string)
          try:
              self.state = 337
              token = self._input.LA(1)
              if token in [UnitXParser.STRING_LITERAL]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 334
                  self.match(UnitXParser.STRING_LITERAL)
  
              elif token in [UnitXParser.BYTES_LITERAL]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 335
                  self.match(UnitXParser.BYTES_LITERAL)
  
              elif token in [UnitXParser.T__2, UnitXParser.T__4]:
                  self.enterOuterAlt(localctx, 3)
                  self.state = 336
                  self.halfString()
  
              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 HalfStringContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.HalfStringContext, self).__init__(parent, invokingState)
              self.parser = parser
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_halfString
  
          def enterRule(self, listener):
              if hasattr(listener, "enterHalfString"):
                  listener.enterHalfString(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitHalfString"):
                  listener.exitHalfString(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitHalfString"):
                  return visitor.visitHalfString(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def halfString(self):
  
          localctx = UnitXParser.HalfStringContext(self, self._ctx, self.state)
          self.enterRule(localctx, 54, self.RULE_halfString)
          self._la = 0 # Token type
          try:
              self.state = 353
              token = self._input.LA(1)
              if token in [UnitXParser.T__2]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 339
                  self.match(UnitXParser.T__2)
                  self.state = 343
                  self._errHandler.sync(self)
                  _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
                  while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                      if _alt==1:
                          self.state = 340
                          _la = self._input.LA(1)
                          if _la <= 0 or _la==UnitXParser.T__3 or _la==UnitXParser.NEWLINE:
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume() 
                      self.state = 345
                      self._errHandler.sync(self)
                      _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
  
  
              elif token in [UnitXParser.T__4]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 346
                  self.match(UnitXParser.T__4)
                  self.state = 350
                  self._errHandler.sync(self)
                  _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
                  while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                      if _alt==1:
                          self.state = 347
                          _la = self._input.LA(1)
                          if _la <= 0 or _la==UnitXParser.T__3 or _la==UnitXParser.NEWLINE:
                              self._errHandler.recoverInline(self)
                          else:
                              self.consume() 
                      self.state = 352
                      self._errHandler.sync(self)
                      _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
  
  
              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 NumberContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.NumberContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def integer(self):
              return self.getTypedRuleContext(UnitXParser.IntegerContext,0)
  
  
          def FLOAT_NUMBER(self):
              return self.getToken(UnitXParser.FLOAT_NUMBER, 0)
  
          def IMAG_NUMBER(self):
              return self.getToken(UnitXParser.IMAG_NUMBER, 0)
  
          def getRuleIndex(self):
              return UnitXParser.RULE_number
  
          def enterRule(self, listener):
              if hasattr(listener, "enterNumber"):
                  listener.enterNumber(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitNumber"):
                  listener.exitNumber(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitNumber"):
                  return visitor.visitNumber(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def number(self):
  
          localctx = UnitXParser.NumberContext(self, self._ctx, self.state)
          self.enterRule(localctx, 56, self.RULE_number)
          try:
              self.state = 358
              token = self._input.LA(1)
              if token in [UnitXParser.DECIMAL_INTEGER, UnitXParser.OCT_INTEGER, UnitXParser.HEX_INTEGER, UnitXParser.BIN_INTEGER]:
                  self.enterOuterAlt(localctx, 1)
                  self.state = 355
                  self.integer()
  
              elif token in [UnitXParser.FLOAT_NUMBER]:
                  self.enterOuterAlt(localctx, 2)
                  self.state = 356
                  self.match(UnitXParser.FLOAT_NUMBER)
  
              elif token in [UnitXParser.IMAG_NUMBER]:
                  self.enterOuterAlt(localctx, 3)
                  self.state = 357
                  self.match(UnitXParser.IMAG_NUMBER)
  
              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 IntegerContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.IntegerContext, self).__init__(parent, invokingState)
              self.parser = parser
  
          def DECIMAL_INTEGER(self):
              return self.getToken(UnitXParser.DECIMAL_INTEGER, 0)
  
          def OCT_INTEGER(self):
              return self.getToken(UnitXParser.OCT_INTEGER, 0)
  
          def HEX_INTEGER(self):
              return self.getToken(UnitXParser.HEX_INTEGER, 0)
  
          def BIN_INTEGER(self):
              return self.getToken(UnitXParser.BIN_INTEGER, 0)
  
          def getRuleIndex(self):
              return UnitXParser.RULE_integer
  
          def enterRule(self, listener):
              if hasattr(listener, "enterInteger"):
                  listener.enterInteger(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitInteger"):
                  listener.exitInteger(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitInteger"):
                  return visitor.visitInteger(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def integer(self):
  
          localctx = UnitXParser.IntegerContext(self, self._ctx, self.state)
          self.enterRule(localctx, 58, self.RULE_integer)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 360
              _la = self._input.LA(1)
              if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (UnitXParser.DECIMAL_INTEGER - 73)) | (1 << (UnitXParser.OCT_INTEGER - 73)) | (1 << (UnitXParser.HEX_INTEGER - 73)) | (1 << (UnitXParser.BIN_INTEGER - 73)))) != 0)):
                  self._errHandler.recoverInline(self)
              else:
                  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 BooleanContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.BooleanContext, self).__init__(parent, invokingState)
              self.parser = parser
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_boolean
  
          def enterRule(self, listener):
              if hasattr(listener, "enterBoolean"):
                  listener.enterBoolean(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitBoolean"):
                  listener.exitBoolean(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitBoolean"):
                  return visitor.visitBoolean(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def boolean(self):
  
          localctx = UnitXParser.BooleanContext(self, self._ctx, self.state)
          self.enterRule(localctx, 60, self.RULE_boolean)
          self._la = 0 # Token type
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 362
              _la = self._input.LA(1)
              if not(_la==UnitXParser.T__5 or _la==UnitXParser.T__6):
                  self._errHandler.recoverInline(self)
              else:
                  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 NoneContext(ParserRuleContext):
  
          def __init__(self, parser, parent=None, invokingState=-1):
              super(UnitXParser.NoneContext, self).__init__(parent, invokingState)
              self.parser = parser
  
  
          def getRuleIndex(self):
              return UnitXParser.RULE_none
  
          def enterRule(self, listener):
              if hasattr(listener, "enterNone"):
                  listener.enterNone(self)
  
          def exitRule(self, listener):
              if hasattr(listener, "exitNone"):
                  listener.exitNone(self)
  
          def accept(self, visitor):
              if hasattr(visitor, "visitNone"):
                  return visitor.visitNone(self)
              else:
                  return visitor.visitChildren(self)
  
  
  
  
      def none(self):
  
          localctx = UnitXParser.NoneContext(self, self._ctx, self.state)
          self.enterRule(localctx, 62, self.RULE_none)
          try:
              self.enterOuterAlt(localctx, 1)
              self.state = 364
              self.match(UnitXParser.T__7)
          except RecognitionException as re:
              localctx.exception = re
              self._errHandler.reportError(self, re)
              self._errHandler.recover(self, re)
          finally:
              self.exitRule()
          return localctx
  
  
  
      def sempred(self, localctx, ruleIndex, predIndex):
          if self._predicates == None:
              self._predicates = dict()
          self._predicates[20] = 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 expression_sempred(self, localctx, predIndex):
              if predIndex == 0:
                  return self.precpred(self._ctx, 9)
           
  
              if predIndex == 1:
                  return self.precpred(self._ctx, 8)
           
  
              if predIndex == 2:
                  return self.precpred(self._ctx, 7)
           
  
              if predIndex == 3:
                  return self.precpred(self._ctx, 6)
           
  
              if predIndex == 4:
                  return self.precpred(self._ctx, 5)
           
  
              if predIndex == 5:
                  return self.precpred(self._ctx, 4)
           
  
              if predIndex == 6:
                  return self.precpred(self._ctx, 10)
           
  
  
  
  
  