# Generated from Spud.g4 by ANTLR 4.9.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3!")
        buf.write("\u027e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\3\2\7\2\u0080\n\2\f\2\16\2\u0083")
        buf.write("\13\2\3\2\3\2\7\2\u0087\n\2\f\2\16\2\u008a\13\2\3\3\3")
        buf.write("\3\3\3\7\3\u008f\n\3\f\3\16\3\u0092\13\3\3\4\7\4\u0095")
        buf.write("\n\4\f\4\16\4\u0098\13\4\3\4\3\4\3\4\3\5\3\5\7\5\u009f")
        buf.write("\n\5\f\5\16\5\u00a2\13\5\3\5\3\5\7\5\u00a6\n\5\f\5\16")
        buf.write("\5\u00a9\13\5\3\5\3\5\3\6\3\6\6\6\u00af\n\6\r\6\16\6\u00b0")
        buf.write("\3\6\3\6\3\7\3\7\3\7\3\7\3\7\5\7\u00ba\n\7\3\b\3\b\7\b")
        buf.write("\u00be\n\b\f\b\16\b\u00c1\13\b\3\t\3\t\7\t\u00c5\n\t\f")
        buf.write("\t\16\t\u00c8\13\t\3\t\3\t\3\n\3\n\5\n\u00ce\n\n\3\13")
        buf.write("\7\13\u00d1\n\13\f\13\16\13\u00d4\13\13\3\13\3\13\7\13")
        buf.write("\u00d8\n\13\f\13\16\13\u00db\13\13\3\13\3\13\3\f\7\f\u00e0")
        buf.write("\n\f\f\f\16\f\u00e3\13\f\3\r\7\r\u00e6\n\r\f\r\16\r\u00e9")
        buf.write("\13\r\3\r\3\r\7\r\u00ed\n\r\f\r\16\r\u00f0\13\r\3\r\3")
        buf.write("\r\3\16\7\16\u00f5\n\16\f\16\16\16\u00f8\13\16\3\17\7")
        buf.write("\17\u00fb\n\17\f\17\16\17\u00fe\13\17\3\17\3\17\7\17\u0102")
        buf.write("\n\17\f\17\16\17\u0105\13\17\3\17\3\17\3\20\3\20\7\20")
        buf.write("\u010b\n\20\f\20\16\20\u010e\13\20\3\21\3\21\3\21\7\21")
        buf.write("\u0113\n\21\f\21\16\21\u0116\13\21\3\22\3\22\3\22\3\23")
        buf.write("\3\23\6\23\u011d\n\23\r\23\16\23\u011e\3\23\3\23\6\23")
        buf.write("\u0123\n\23\r\23\16\23\u0124\5\23\u0127\n\23\5\23\u0129")
        buf.write("\n\23\3\23\3\23\3\24\5\24\u012e\n\24\3\24\3\24\5\24\u0132")
        buf.write("\n\24\3\25\3\25\3\25\3\26\3\26\3\26\3\27\3\27\3\27\3\30")
        buf.write("\3\30\3\30\3\31\3\31\5\31\u0142\n\31\3\32\3\32\5\32\u0146")
        buf.write("\n\32\3\33\3\33\3\33\7\33\u014b\n\33\f\33\16\33\u014e")
        buf.write("\13\33\3\34\3\34\3\34\7\34\u0153\n\34\f\34\16\34\u0156")
        buf.write("\13\34\3\35\3\35\3\35\7\35\u015b\n\35\f\35\16\35\u015e")
        buf.write("\13\35\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3")
        buf.write(" \3 \3!\3!\6!\u016e\n!\r!\16!\u016f\3!\3!\3\"\3\"\5\"")
        buf.write("\u0176\n\"\3\"\6\"\u0179\n\"\r\"\16\"\u017a\3\"\3\"\3")
        buf.write("#\3#\3#\7#\u0182\n#\f#\16#\u0185\13#\3$\3$\3$\7$\u018a")
        buf.write("\n$\f$\16$\u018d\13$\3%\3%\3%\3%\3&\3&\6&\u0195\n&\r&")
        buf.write("\16&\u0196\3&\3&\3\'\3\'\6\'\u019d\n\'\r\'\16\'\u019e")
        buf.write("\3\'\3\'\3(\3(\6(\u01a5\n(\r(\16(\u01a6\3(\3(\5(\u01ab")
        buf.write("\n(\3)\3)\5)\u01af\n)\3)\6)\u01b2\n)\r)\16)\u01b3\3)\3")
        buf.write(")\5)\u01b8\n)\3)\6)\u01bb\n)\r)\16)\u01bc\3)\3)\3*\3*")
        buf.write("\3*\7*\u01c4\n*\f*\16*\u01c7\13*\3+\3+\3+\7+\u01cc\n+")
        buf.write("\f+\16+\u01cf\13+\3,\3,\3,\3,\3-\3-\3-\3-\3-\5-\u01da")
        buf.write("\n-\3.\3.\6.\u01de\n.\r.\16.\u01df\3.\7.\u01e3\n.\f.\16")
        buf.write(".\u01e6\13.\3/\3/\6/\u01ea\n/\r/\16/\u01eb\3/\7/\u01ef")
        buf.write("\n/\f/\16/\u01f2\13/\3\60\3\60\6\60\u01f6\n\60\r\60\16")
        buf.write("\60\u01f7\3\60\3\60\3\61\3\61\6\61\u01fe\n\61\r\61\16")
        buf.write("\61\u01ff\3\61\3\61\5\61\u0204\n\61\3\62\6\62\u0207\n")
        buf.write("\62\r\62\16\62\u0208\3\62\3\62\5\62\u020d\n\62\3\63\3")
        buf.write("\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66")
        buf.write("\3\67\3\67\38\38\68\u021f\n8\r8\168\u0220\38\38\39\39")
        buf.write("\69\u0227\n9\r9\169\u0228\39\39\59\u022d\n9\39\79\u0230")
        buf.write("\n9\f9\169\u0233\139\39\59\u0236\n9\3:\7:\u0239\n:\f:")
        buf.write("\16:\u023c\13:\3:\3:\3;\3;\3;\3;\3;\7;\u0245\n;\f;\16")
        buf.write(";\u0248\13;\3;\3;\3<\3<\3<\3<\3<\3<\3<\5<\u0253\n<\3=")
        buf.write("\3=\7=\u0257\n=\f=\16=\u025a\13=\3>\7>\u025d\n>\f>\16")
        buf.write(">\u0260\13>\3>\3>\3>\3>\5>\u0266\n>\3>\7>\u0269\n>\f>")
        buf.write("\16>\u026c\13>\5>\u026e\n>\3>\5>\u0271\n>\3?\3?\3?\7?")
        buf.write("\u0276\n?\f?\16?\u0279\13?\3?\3?\3?\3?\2\2@\2\4\6\b\n")
        buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<")
        buf.write(">@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|\2\7\3\2\32\33\3\2\5")
        buf.write("\6\3\2\31\31\3\2\b\b\3\2\t\n\2\u0295\2\u0081\3\2\2\2\4")
        buf.write("\u008b\3\2\2\2\6\u0096\3\2\2\2\b\u009c\3\2\2\2\n\u00ac")
        buf.write("\3\2\2\2\f\u00b9\3\2\2\2\16\u00bb\3\2\2\2\20\u00c2\3\2")
        buf.write("\2\2\22\u00cd\3\2\2\2\24\u00d2\3\2\2\2\26\u00e1\3\2\2")
        buf.write("\2\30\u00e7\3\2\2\2\32\u00f6\3\2\2\2\34\u00fc\3\2\2\2")
        buf.write("\36\u010c\3\2\2\2 \u010f\3\2\2\2\"\u0117\3\2\2\2$\u0128")
        buf.write("\3\2\2\2&\u012d\3\2\2\2(\u0133\3\2\2\2*\u0136\3\2\2\2")
        buf.write(",\u0139\3\2\2\2.\u013c\3\2\2\2\60\u0141\3\2\2\2\62\u0145")
        buf.write("\3\2\2\2\64\u0147\3\2\2\2\66\u014f\3\2\2\28\u0157\3\2")
        buf.write("\2\2:\u015f\3\2\2\2<\u0163\3\2\2\2>\u0167\3\2\2\2@\u016b")
        buf.write("\3\2\2\2B\u0175\3\2\2\2D\u017e\3\2\2\2F\u0186\3\2\2\2")
        buf.write("H\u018e\3\2\2\2J\u0192\3\2\2\2L\u019a\3\2\2\2N\u01a2\3")
        buf.write("\2\2\2P\u01ae\3\2\2\2R\u01c0\3\2\2\2T\u01c8\3\2\2\2V\u01d0")
        buf.write("\3\2\2\2X\u01d9\3\2\2\2Z\u01db\3\2\2\2\\\u01e7\3\2\2\2")
        buf.write("^\u01f3\3\2\2\2`\u01fb\3\2\2\2b\u0206\3\2\2\2d\u020e\3")
        buf.write("\2\2\2f\u0211\3\2\2\2h\u0214\3\2\2\2j\u0217\3\2\2\2l\u021a")
        buf.write("\3\2\2\2n\u021c\3\2\2\2p\u0224\3\2\2\2r\u023a\3\2\2\2")
        buf.write("t\u023f\3\2\2\2v\u0252\3\2\2\2x\u0254\3\2\2\2z\u025e\3")
        buf.write("\2\2\2|\u0277\3\2\2\2~\u0080\7\32\2\2\177~\3\2\2\2\u0080")
        buf.write("\u0083\3\2\2\2\u0081\177\3\2\2\2\u0081\u0082\3\2\2\2\u0082")
        buf.write("\u0084\3\2\2\2\u0083\u0081\3\2\2\2\u0084\u0088\7\33\2")
        buf.write("\2\u0085\u0087\t\2\2\2\u0086\u0085\3\2\2\2\u0087\u008a")
        buf.write("\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089")
        buf.write("\3\3\2\2\2\u008a\u0088\3\2\2\2\u008b\u008c\5\2\2\2\u008c")
        buf.write("\u0090\7\3\2\2\u008d\u008f\t\2\2\2\u008e\u008d\3\2\2\2")
        buf.write("\u008f\u0092\3\2\2\2\u0090\u008e\3\2\2\2\u0090\u0091\3")
        buf.write("\2\2\2\u0091\5\3\2\2\2\u0092\u0090\3\2\2\2\u0093\u0095")
        buf.write("\7\32\2\2\u0094\u0093\3\2\2\2\u0095\u0098\3\2\2\2\u0096")
        buf.write("\u0094\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0099\3\2\2\2")
        buf.write("\u0098\u0096\3\2\2\2\u0099\u009a\7\3\2\2\u009a\u009b\5")
        buf.write("\2\2\2\u009b\7\3\2\2\2\u009c\u00a0\5\2\2\2\u009d\u009f")
        buf.write("\7\30\2\2\u009e\u009d\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0")
        buf.write("\u009e\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a3\3\2\2\2")
        buf.write("\u00a2\u00a0\3\2\2\2\u00a3\u00a7\7\4\2\2\u00a4\u00a6\7")
        buf.write("\30\2\2\u00a5\u00a4\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7")
        buf.write("\u00a5\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00aa\3\2\2\2")
        buf.write("\u00a9\u00a7\3\2\2\2\u00aa\u00ab\5\2\2\2\u00ab\t\3\2\2")
        buf.write("\2\u00ac\u00ae\5\2\2\2\u00ad\u00af\7\30\2\2\u00ae\u00ad")
        buf.write("\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0")
        buf.write("\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\5\b\5\2")
        buf.write("\u00b3\13\3\2\2\2\u00b4\u00ba\5\2\2\2\u00b5\u00ba\5\4")
        buf.write("\3\2\u00b6\u00ba\5\6\4\2\u00b7\u00ba\5\b\5\2\u00b8\u00ba")
        buf.write("\5\n\6\2\u00b9\u00b4\3\2\2\2\u00b9\u00b5\3\2\2\2\u00b9")
        buf.write("\u00b6\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2")
        buf.write("\u00ba\r\3\2\2\2\u00bb\u00bf\t\3\2\2\u00bc\u00be\n\4\2")
        buf.write("\2\u00bd\u00bc\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf\u00bd")
        buf.write("\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\17\3\2\2\2\u00c1\u00bf")
        buf.write("\3\2\2\2\u00c2\u00c6\7\7\2\2\u00c3\u00c5\n\5\2\2\u00c4")
        buf.write("\u00c3\3\2\2\2\u00c5\u00c8\3\2\2\2\u00c6\u00c4\3\2\2\2")
        buf.write("\u00c6\u00c7\3\2\2\2\u00c7\u00c9\3\2\2\2\u00c8\u00c6\3")
        buf.write("\2\2\2\u00c9\u00ca\7\b\2\2\u00ca\21\3\2\2\2\u00cb\u00ce")
        buf.write("\7\31\2\2\u00cc\u00ce\5\20\t\2\u00cd\u00cb\3\2\2\2\u00cd")
        buf.write("\u00cc\3\2\2\2\u00ce\23\3\2\2\2\u00cf\u00d1\7\30\2\2\u00d0")
        buf.write("\u00cf\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2")
        buf.write("\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2\2\2\u00d4\u00d2\3")
        buf.write("\2\2\2\u00d5\u00d9\7\t\2\2\u00d6\u00d8\7\30\2\2\u00d7")
        buf.write("\u00d6\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2")
        buf.write("\u00d9\u00da\3\2\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3")
        buf.write("\2\2\2\u00dc\u00dd\7\34\2\2\u00dd\25\3\2\2\2\u00de\u00e0")
        buf.write("\5\24\13\2\u00df\u00de\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1")
        buf.write("\u00df\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\27\3\2\2\2\u00e3")
        buf.write("\u00e1\3\2\2\2\u00e4\u00e6\7\30\2\2\u00e5\u00e4\3\2\2")
        buf.write("\2\u00e6\u00e9\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8")
        buf.write("\3\2\2\2\u00e8\u00ea\3\2\2\2\u00e9\u00e7\3\2\2\2\u00ea")
        buf.write("\u00ee\t\6\2\2\u00eb\u00ed\7\30\2\2\u00ec\u00eb\3\2\2")
        buf.write("\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef")
        buf.write("\3\2\2\2\u00ef\u00f1\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1")
        buf.write("\u00f2\7\34\2\2\u00f2\31\3\2\2\2\u00f3\u00f5\5\30\r\2")
        buf.write("\u00f4\u00f3\3\2\2\2\u00f5\u00f8\3\2\2\2\u00f6\u00f4\3")
        buf.write("\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\33\3\2\2\2\u00f8\u00f6")
        buf.write("\3\2\2\2\u00f9\u00fb\7\30\2\2\u00fa\u00f9\3\2\2\2\u00fb")
        buf.write("\u00fe\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2")
        buf.write("\u00fd\u00ff\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff\u0103\7")
        buf.write("\n\2\2\u0100\u0102\7\30\2\2\u0101\u0100\3\2\2\2\u0102")
        buf.write("\u0105\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2")
        buf.write("\u0104\u0106\3\2\2\2\u0105\u0103\3\2\2\2\u0106\u0107\7")
        buf.write("\13\2\2\u0107\35\3\2\2\2\u0108\u010b\5\30\r\2\u0109\u010b")
        buf.write("\5\34\17\2\u010a\u0108\3\2\2\2\u010a\u0109\3\2\2\2\u010b")
        buf.write("\u010e\3\2\2\2\u010c\u010a\3\2\2\2\u010c\u010d\3\2\2\2")
        buf.write("\u010d\37\3\2\2\2\u010e\u010c\3\2\2\2\u010f\u0114\7\34")
        buf.write("\2\2\u0110\u0111\7\3\2\2\u0111\u0113\7\34\2\2\u0112\u0110")
        buf.write("\3\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114")
        buf.write("\u0115\3\2\2\2\u0115!\3\2\2\2\u0116\u0114\3\2\2\2\u0117")
        buf.write("\u0118\5 \21\2\u0118\u0119\5\26\f\2\u0119#\3\2\2\2\u011a")
        buf.write("\u011c\5\f\7\2\u011b\u011d\7\30\2\2\u011c\u011b\3\2\2")
        buf.write("\2\u011d\u011e\3\2\2\2\u011e\u011c\3\2\2\2\u011e\u011f")
        buf.write("\3\2\2\2\u011f\u0126\3\2\2\2\u0120\u0122\5 \21\2\u0121")
        buf.write("\u0123\7\30\2\2\u0122\u0121\3\2\2\2\u0123\u0124\3\2\2")
        buf.write("\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125\u0127")
        buf.write("\3\2\2\2\u0126\u0120\3\2\2\2\u0126\u0127\3\2\2\2\u0127")
        buf.write("\u0129\3\2\2\2\u0128\u011a\3\2\2\2\u0128\u0129\3\2\2\2")
        buf.write("\u0129\u012a\3\2\2\2\u012a\u012b\5\"\22\2\u012b%\3\2\2")
        buf.write("\2\u012c\u012e\7\f\2\2\u012d\u012c\3\2\2\2\u012d\u012e")
        buf.write("\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0131\5 \21\2\u0130")
        buf.write("\u0132\7\f\2\2\u0131\u0130\3\2\2\2\u0131\u0132\3\2\2\2")
        buf.write("\u0132\'\3\2\2\2\u0133\u0134\5&\24\2\u0134\u0135\5\32")
        buf.write("\16\2\u0135)\3\2\2\2\u0136\u0137\5 \21\2\u0137\u0138\5")
        buf.write("\36\20\2\u0138+\3\2\2\2\u0139\u013a\7\13\2\2\u013a\u013b")
        buf.write("\5\32\16\2\u013b-\3\2\2\2\u013c\u013d\7\13\2\2\u013d\u013e")
        buf.write("\5\36\20\2\u013e/\3\2\2\2\u013f\u0142\5(\25\2\u0140\u0142")
        buf.write("\5,\27\2\u0141\u013f\3\2\2\2\u0141\u0140\3\2\2\2\u0142")
        buf.write("\61\3\2\2\2\u0143\u0146\5*\26\2\u0144\u0146\5.\30\2\u0145")
        buf.write("\u0143\3\2\2\2\u0145\u0144\3\2\2\2\u0146\63\3\2\2\2\u0147")
        buf.write("\u014c\5(\25\2\u0148\u0149\7\35\2\2\u0149\u014b\5(\25")
        buf.write("\2\u014a\u0148\3\2\2\2\u014b\u014e\3\2\2\2\u014c\u014a")
        buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d\65\3\2\2\2\u014e\u014c")
        buf.write("\3\2\2\2\u014f\u0154\5*\26\2\u0150\u0151\7\35\2\2\u0151")
        buf.write("\u0153\5*\26\2\u0152\u0150\3\2\2\2\u0153\u0156\3\2\2\2")
        buf.write("\u0154\u0152\3\2\2\2\u0154\u0155\3\2\2\2\u0155\67\3\2")
        buf.write("\2\2\u0156\u0154\3\2\2\2\u0157\u015c\5\62\32\2\u0158\u0159")
        buf.write("\7\35\2\2\u0159\u015b\5\62\32\2\u015a\u0158\3\2\2\2\u015b")
        buf.write("\u015e\3\2\2\2\u015c\u015a\3\2\2\2\u015c\u015d\3\2\2\2")
        buf.write("\u015d9\3\2\2\2\u015e\u015c\3\2\2\2\u015f\u0160\5\64\33")
        buf.write("\2\u0160\u0161\7\36\2\2\u0161\u0162\58\35\2\u0162;\3\2")
        buf.write("\2\2\u0163\u0164\5\64\33\2\u0164\u0165\7\37\2\2\u0165")
        buf.write("\u0166\58\35\2\u0166=\3\2\2\2\u0167\u0168\5\64\33\2\u0168")
        buf.write("\u0169\7 \2\2\u0169\u016a\5\66\34\2\u016a?\3\2\2\2\u016b")
        buf.write("\u016d\5\f\7\2\u016c\u016e\7\30\2\2\u016d\u016c\3\2\2")
        buf.write("\2\u016e\u016f\3\2\2\2\u016f\u016d\3\2\2\2\u016f\u0170")
        buf.write("\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0172\5(\25\2\u0172")
        buf.write("A\3\2\2\2\u0173\u0176\5\f\7\2\u0174\u0176\7\13\2\2\u0175")
        buf.write("\u0173\3\2\2\2\u0175\u0174\3\2\2\2\u0176\u0178\3\2\2\2")
        buf.write("\u0177\u0179\7\30\2\2\u0178\u0177\3\2\2\2\u0179\u017a")
        buf.write("\3\2\2\2\u017a\u0178\3\2\2\2\u017a\u017b\3\2\2\2\u017b")
        buf.write("\u017c\3\2\2\2\u017c\u017d\5\62\32\2\u017dC\3\2\2\2\u017e")
        buf.write("\u0183\5@!\2\u017f\u0180\7\35\2\2\u0180\u0182\5@!\2\u0181")
        buf.write("\u017f\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2")
        buf.write("\u0183\u0184\3\2\2\2\u0184E\3\2\2\2\u0185\u0183\3\2\2")
        buf.write("\2\u0186\u018b\5B\"\2\u0187\u0188\7\35\2\2\u0188\u018a")
        buf.write("\5B\"\2\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2\2\u018b")
        buf.write("\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018cG\3\2\2\2\u018d")
        buf.write("\u018b\3\2\2\2\u018e\u018f\5D#\2\u018f\u0190\7\36\2\2")
        buf.write("\u0190\u0191\5F$\2\u0191I\3\2\2\2\u0192\u0194\7\13\2\2")
        buf.write("\u0193\u0195\7\30\2\2\u0194\u0193\3\2\2\2\u0195\u0196")
        buf.write("\3\2\2\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197")
        buf.write("\u0198\3\2\2\2\u0198\u0199\5(\25\2\u0199K\3\2\2\2\u019a")
        buf.write("\u019c\5&\24\2\u019b\u019d\7\30\2\2\u019c\u019b\3\2\2")
        buf.write("\2\u019d\u019e\3\2\2\2\u019e\u019c\3\2\2\2\u019e\u019f")
        buf.write("\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\5\60\31\2\u01a1")
        buf.write("M\3\2\2\2\u01a2\u01a4\5\f\7\2\u01a3\u01a5\7\30\2\2\u01a4")
        buf.write("\u01a3\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a4\3\2\2\2")
        buf.write("\u01a6\u01a7\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8\u01ab\5")
        buf.write("J&\2\u01a9\u01ab\5L\'\2\u01aa\u01a8\3\2\2\2\u01aa\u01a9")
        buf.write("\3\2\2\2\u01abO\3\2\2\2\u01ac\u01af\5\f\7\2\u01ad\u01af")
        buf.write("\7\13\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af")
        buf.write("\u01b1\3\2\2\2\u01b0\u01b2\7\30\2\2\u01b1\u01b0\3\2\2")
        buf.write("\2\u01b2\u01b3\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b3\u01b4")
        buf.write("\3\2\2\2\u01b4\u01b7\3\2\2\2\u01b5\u01b8\5 \21\2\u01b6")
        buf.write("\u01b8\7\13\2\2\u01b7\u01b5\3\2\2\2\u01b7\u01b6\3\2\2")
        buf.write("\2\u01b8\u01ba\3\2\2\2\u01b9\u01bb\7\30\2\2\u01ba\u01b9")
        buf.write("\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc")
        buf.write("\u01bd\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01bf\5\62\32")
        buf.write("\2\u01bfQ\3\2\2\2\u01c0\u01c5\5N(\2\u01c1\u01c2\7\35\2")
        buf.write("\2\u01c2\u01c4\5N(\2\u01c3\u01c1\3\2\2\2\u01c4\u01c7\3")
        buf.write("\2\2\2\u01c5\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6S")
        buf.write("\3\2\2\2\u01c7\u01c5\3\2\2\2\u01c8\u01cd\5P)\2\u01c9\u01ca")
        buf.write("\7\35\2\2\u01ca\u01cc\5P)\2\u01cb\u01c9\3\2\2\2\u01cc")
        buf.write("\u01cf\3\2\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2")
        buf.write("\u01ceU\3\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\5R*\2")
        buf.write("\u01d1\u01d2\7\36\2\2\u01d2\u01d3\5T+\2\u01d3W\3\2\2\2")
        buf.write("\u01d4\u01da\5:\36\2\u01d5\u01da\5<\37\2\u01d6\u01da\5")
        buf.write("> \2\u01d7\u01da\5H%\2\u01d8\u01da\5V,\2\u01d9\u01d4\3")
        buf.write("\2\2\2\u01d9\u01d5\3\2\2\2\u01d9\u01d6\3\2\2\2\u01d9\u01d7")
        buf.write("\3\2\2\2\u01d9\u01d8\3\2\2\2\u01daY\3\2\2\2\u01db\u01dd")
        buf.write("\7\r\2\2\u01dc\u01de\7\30\2\2\u01dd\u01dc\3\2\2\2\u01de")
        buf.write("\u01df\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2")
        buf.write("\u01e0\u01e4\3\2\2\2\u01e1\u01e3\n\4\2\2\u01e2\u01e1\3")
        buf.write("\2\2\2\u01e3\u01e6\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e4\u01e5")
        buf.write("\3\2\2\2\u01e5[\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e7\u01e9")
        buf.write("\7\16\2\2\u01e8\u01ea\7\30\2\2\u01e9\u01e8\3\2\2\2\u01ea")
        buf.write("\u01eb\3\2\2\2\u01eb\u01e9\3\2\2\2\u01eb\u01ec\3\2\2\2")
        buf.write("\u01ec\u01f0\3\2\2\2\u01ed\u01ef\n\4\2\2\u01ee\u01ed\3")
        buf.write("\2\2\2\u01ef\u01f2\3\2\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01f1")
        buf.write("\3\2\2\2\u01f1]\3\2\2\2\u01f2\u01f0\3\2\2\2\u01f3\u01f5")
        buf.write("\7\13\2\2\u01f4\u01f6\7\30\2\2\u01f5\u01f4\3\2\2\2\u01f6")
        buf.write("\u01f7\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2")
        buf.write("\u01f8\u01f9\3\2\2\2\u01f9\u01fa\5(\25\2\u01fa_\3\2\2")
        buf.write("\2\u01fb\u01fd\5&\24\2\u01fc\u01fe\7\30\2\2\u01fd\u01fc")
        buf.write("\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff")
        buf.write("\u0200\3\2\2\2\u0200\u0203\3\2\2\2\u0201\u0204\5\60\31")
        buf.write("\2\u0202\u0204\7\13\2\2\u0203\u0201\3\2\2\2\u0203\u0202")
        buf.write("\3\2\2\2\u0204a\3\2\2\2\u0205\u0207\7\30\2\2\u0206\u0205")
        buf.write("\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0206\3\2\2\2\u0208")
        buf.write("\u0209\3\2\2\2\u0209\u020c\3\2\2\2\u020a\u020d\5^\60\2")
        buf.write("\u020b\u020d\5`\61\2\u020c\u020a\3\2\2\2\u020c\u020b\3")
        buf.write("\2\2\2\u020dc\3\2\2\2\u020e\u020f\7\17\2\2\u020f\u0210")
        buf.write("\5b\62\2\u0210e\3\2\2\2\u0211\u0212\7\20\2\2\u0212\u0213")
        buf.write("\5b\62\2\u0213g\3\2\2\2\u0214\u0215\7\21\2\2\u0215\u0216")
        buf.write("\5b\62\2\u0216i\3\2\2\2\u0217\u0218\7\22\2\2\u0218\u0219")
        buf.write("\5b\62\2\u0219k\3\2\2\2\u021a\u021b\7\23\2\2\u021bm\3")
        buf.write("\2\2\2\u021c\u021e\7\24\2\2\u021d\u021f\7\30\2\2\u021e")
        buf.write("\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u021e\3\2\2\2")
        buf.write("\u0220\u0221\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0223\5")
        buf.write("\f\7\2\u0223o\3\2\2\2\u0224\u0226\7\25\2\2\u0225\u0227")
        buf.write("\7\30\2\2\u0226\u0225\3\2\2\2\u0227\u0228\3\2\2\2\u0228")
        buf.write("\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022c\3\2\2\2")
        buf.write("\u022a\u022d\5l\67\2\u022b\u022d\5n8\2\u022c\u022a\3\2")
        buf.write("\2\2\u022c\u022b\3\2\2\2\u022d\u0231\3\2\2\2\u022e\u0230")
        buf.write("\7\30\2\2\u022f\u022e\3\2\2\2\u0230\u0233\3\2\2\2\u0231")
        buf.write("\u022f\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0235\3\2\2\2")
        buf.write("\u0233\u0231\3\2\2\2\u0234\u0236\5\16\b\2\u0235\u0234")
        buf.write("\3\2\2\2\u0235\u0236\3\2\2\2\u0236q\3\2\2\2\u0237\u0239")
        buf.write("\7\30\2\2\u0238\u0237\3\2\2\2\u0239\u023c\3\2\2\2\u023a")
        buf.write("\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023d\3\2\2\2")
        buf.write("\u023c\u023a\3\2\2\2\u023d\u023e\7\26\2\2\u023es\3\2\2")
        buf.write("\2\u023f\u0240\5p9\2\u0240\u0246\5\22\n\2\u0241\u0242")
        buf.write("\5z>\2\u0242\u0243\5\22\n\2\u0243\u0245\3\2\2\2\u0244")
        buf.write("\u0241\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2")
        buf.write("\u0246\u0247\3\2\2\2\u0247\u0249\3\2\2\2\u0248\u0246\3")
        buf.write("\2\2\2\u0249\u024a\5r:\2\u024au\3\2\2\2\u024b\u0253\5")
        buf.write("Z.\2\u024c\u0253\5\\/\2\u024d\u0253\5d\63\2\u024e\u0253")
        buf.write("\5f\64\2\u024f\u0253\5h\65\2\u0250\u0253\5j\66\2\u0251")
        buf.write("\u0253\5t;\2\u0252\u024b\3\2\2\2\u0252\u024c\3\2\2\2\u0252")
        buf.write("\u024d\3\2\2\2\u0252\u024e\3\2\2\2\u0252\u024f\3\2\2\2")
        buf.write("\u0252\u0250\3\2\2\2\u0252\u0251\3\2\2\2\u0253w\3\2\2")
        buf.write("\2\u0254\u0258\7\27\2\2\u0255\u0257\n\4\2\2\u0256\u0255")
        buf.write("\3\2\2\2\u0257\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0258")
        buf.write("\u0259\3\2\2\2\u0259y\3\2\2\2\u025a\u0258\3\2\2\2\u025b")
        buf.write("\u025d\7\30\2\2\u025c\u025b\3\2\2\2\u025d\u0260\3\2\2")
        buf.write("\2\u025e\u025c\3\2\2\2\u025e\u025f\3\2\2\2\u025f\u026d")
        buf.write("\3\2\2\2\u0260\u025e\3\2\2\2\u0261\u0266\5$\23\2\u0262")
        buf.write("\u0266\5X-\2\u0263\u0266\5v<\2\u0264\u0266\5x=\2\u0265")
        buf.write("\u0261\3\2\2\2\u0265\u0262\3\2\2\2\u0265\u0263\3\2\2\2")
        buf.write("\u0265\u0264\3\2\2\2\u0266\u026a\3\2\2\2\u0267\u0269\7")
        buf.write("\30\2\2\u0268\u0267\3\2\2\2\u0269\u026c\3\2\2\2\u026a")
        buf.write("\u0268\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026e\3\2\2\2")
        buf.write("\u026c\u026a\3\2\2\2\u026d\u0265\3\2\2\2\u026d\u026e\3")
        buf.write("\2\2\2\u026e\u0270\3\2\2\2\u026f\u0271\5\16\b\2\u0270")
        buf.write("\u026f\3\2\2\2\u0270\u0271\3\2\2\2\u0271{\3\2\2\2\u0272")
        buf.write("\u0273\5z>\2\u0273\u0274\5\22\n\2\u0274\u0276\3\2\2\2")
        buf.write("\u0275\u0272\3\2\2\2\u0276\u0279\3\2\2\2\u0277\u0275\3")
        buf.write("\2\2\2\u0277\u0278\3\2\2\2\u0278\u027a\3\2\2\2\u0279\u0277")
        buf.write("\3\2\2\2\u027a\u027b\5z>\2\u027b\u027c\7\2\2\3\u027c}")
        buf.write("\3\2\2\2K\u0081\u0088\u0090\u0096\u00a0\u00a7\u00b0\u00b9")
        buf.write("\u00bf\u00c6\u00cd\u00d2\u00d9\u00e1\u00e7\u00ee\u00f6")
        buf.write("\u00fc\u0103\u010a\u010c\u0114\u011e\u0124\u0126\u0128")
        buf.write("\u012d\u0131\u0141\u0145\u014c\u0154\u015c\u016f\u0175")
        buf.write("\u017a\u0183\u018b\u0196\u019e\u01a6\u01aa\u01ae\u01b3")
        buf.write("\u01b7\u01bc\u01c5\u01cd\u01d9\u01df\u01e4\u01eb\u01f0")
        buf.write("\u01f7\u01ff\u0203\u0208\u020c\u0220\u0228\u022c\u0231")
        buf.write("\u0235\u023a\u0246\u0252\u0258\u025e\u0265\u026a\u026d")
        buf.write("\u0270\u0277")
        return buf.getvalue()


class SpudParser ( Parser ):

    grammarFileName = "Spud.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'.'", "'/'", "'#'", "'//'", "'/*'", "'*/'", 
                     "'+'", "'-'", "'$'", "'!'", "'@import'", "'@run'", 
                     "'@hold'", "'@holdunit'", "'@dec'", "'@frac'", "'isolate'", 
                     "'multiply'", "'@begin'", "'@end'", "'spudversion'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "Inlinewhitespacetoken", 
                      "Returnwhitespacetoken", "Zerotoken", "Nonzerotoken", 
                      "Namesegment", "And", "Is", "Istype", "Issynonym", 
                      "Catchall" ]

    RULE_nonzerostring = 0
    RULE_decimallarge = 1
    RULE_decimalsmall = 2
    RULE_fractionsimple = 3
    RULE_fractioncomplex = 4
    RULE_number = 5
    RULE_onelinecomment = 6
    RULE_multilinecomment = 7
    RULE_linebreak = 8
    RULE_propspluselem = 9
    RULE_propsplus = 10
    RULE_propselem = 11
    RULE_props = 12
    RULE_propswildelem = 13
    RULE_propswild = 14
    RULE_basicname = 15
    RULE_basicnameplusprops = 16
    RULE_lineingredient = 17
    RULE_powname = 18
    RULE_pownamewithprops = 19
    RULE_basicnamewithpropswild = 20
    RULE_wildcardwithprops = 21
    RULE_wildcardwithpropswild = 22
    RULE_powwildwithprops = 23
    RULE_basicwildwithprops = 24
    RULE_ruleleftsimple = 25
    RULE_rulerightsimple = 26
    RULE_rulerightsimplewild = 27
    RULE_linerenaming = 28
    RULE_lineprefixing = 29
    RULE_lineinserting = 30
    RULE_singleconvertingleftelem = 31
    RULE_singleconvertingrightelem = 32
    RULE_singleconvertingleft = 33
    RULE_singleconvertingright = 34
    RULE_linesingleconverting = 35
    RULE_doubleconvertingleftsub1 = 36
    RULE_doubleconvertingleftsub2 = 37
    RULE_doubleconvertingleftelem = 38
    RULE_doubleconvertingrightelem = 39
    RULE_doubleconvertingleft = 40
    RULE_doubleconvertingright = 41
    RULE_linedoubleconverting = 42
    RULE_linestandardrule = 43
    RULE_atimport = 44
    RULE_atrun = 45
    RULE_atsub1 = 46
    RULE_atsub2 = 47
    RULE_atsub = 48
    RULE_athold = 49
    RULE_atholdunit = 50
    RULE_atdec = 51
    RULE_atfrac = 52
    RULE_atbeginisolate = 53
    RULE_atbeginmultiply = 54
    RULE_atbegin = 55
    RULE_atend = 56
    RULE_atsection = 57
    RULE_lineat = 58
    RULE_verisoncontrol = 59
    RULE_line = 60
    RULE_spud = 61

    ruleNames =  [ "nonzerostring", "decimallarge", "decimalsmall", "fractionsimple", 
                   "fractioncomplex", "number", "onelinecomment", "multilinecomment", 
                   "linebreak", "propspluselem", "propsplus", "propselem", 
                   "props", "propswildelem", "propswild", "basicname", "basicnameplusprops", 
                   "lineingredient", "powname", "pownamewithprops", "basicnamewithpropswild", 
                   "wildcardwithprops", "wildcardwithpropswild", "powwildwithprops", 
                   "basicwildwithprops", "ruleleftsimple", "rulerightsimple", 
                   "rulerightsimplewild", "linerenaming", "lineprefixing", 
                   "lineinserting", "singleconvertingleftelem", "singleconvertingrightelem", 
                   "singleconvertingleft", "singleconvertingright", "linesingleconverting", 
                   "doubleconvertingleftsub1", "doubleconvertingleftsub2", 
                   "doubleconvertingleftelem", "doubleconvertingrightelem", 
                   "doubleconvertingleft", "doubleconvertingright", "linedoubleconverting", 
                   "linestandardrule", "atimport", "atrun", "atsub1", "atsub2", 
                   "atsub", "athold", "atholdunit", "atdec", "atfrac", "atbeginisolate", 
                   "atbeginmultiply", "atbegin", "atend", "atsection", "lineat", 
                   "verisoncontrol", "line", "spud" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    Inlinewhitespacetoken=22
    Returnwhitespacetoken=23
    Zerotoken=24
    Nonzerotoken=25
    Namesegment=26
    And=27
    Is=28
    Istype=29
    Issynonym=30
    Catchall=31

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




    class NonzerostringContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_nonzerostring

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

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




    def nonzerostring(self):

        localctx = SpudParser.NonzerostringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_nonzerostring)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 127
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Zerotoken:
                self.state = 124
                self.match(SpudParser.Zerotoken)
                self.state = 129
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 130
            self.match(SpudParser.Nonzerotoken)
            self.state = 134
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Zerotoken or _la==SpudParser.Nonzerotoken:
                self.state = 131
                _la = self._input.LA(1)
                if not(_la==SpudParser.Zerotoken or _la==SpudParser.Nonzerotoken):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 136
                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 DecimallargeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonzerostring(self):
            return self.getTypedRuleContext(SpudParser.NonzerostringContext,0)


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

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

        def getRuleIndex(self):
            return SpudParser.RULE_decimallarge

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

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




    def decimallarge(self):

        localctx = SpudParser.DecimallargeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_decimallarge)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 137
            self.nonzerostring()
            self.state = 138
            self.match(SpudParser.T__0)
            self.state = 142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Zerotoken or _la==SpudParser.Nonzerotoken:
                self.state = 139
                _la = self._input.LA(1)
                if not(_la==SpudParser.Zerotoken or _la==SpudParser.Nonzerotoken):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 144
                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 DecimalsmallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonzerostring(self):
            return self.getTypedRuleContext(SpudParser.NonzerostringContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_decimalsmall

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

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




    def decimalsmall(self):

        localctx = SpudParser.DecimalsmallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_decimalsmall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 148
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Zerotoken:
                self.state = 145
                self.match(SpudParser.Zerotoken)
                self.state = 150
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 151
            self.match(SpudParser.T__0)
            self.state = 152
            self.nonzerostring()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FractionsimpleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonzerostring(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.NonzerostringContext)
            else:
                return self.getTypedRuleContext(SpudParser.NonzerostringContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_fractionsimple

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

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




    def fractionsimple(self):

        localctx = SpudParser.FractionsimpleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_fractionsimple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 154
            self.nonzerostring()
            self.state = 158
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 155
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 160
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 161
            self.match(SpudParser.T__1)
            self.state = 165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 162
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 167
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class FractioncomplexContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonzerostring(self):
            return self.getTypedRuleContext(SpudParser.NonzerostringContext,0)


        def fractionsimple(self):
            return self.getTypedRuleContext(SpudParser.FractionsimpleContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_fractioncomplex

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

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




    def fractioncomplex(self):

        localctx = SpudParser.FractioncomplexContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_fractioncomplex)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 170
            self.nonzerostring()
            self.state = 172 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 171
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 174 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 176
            self.fractionsimple()
        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):
        __slots__ = 'parser'

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

        def nonzerostring(self):
            return self.getTypedRuleContext(SpudParser.NonzerostringContext,0)


        def decimallarge(self):
            return self.getTypedRuleContext(SpudParser.DecimallargeContext,0)


        def decimalsmall(self):
            return self.getTypedRuleContext(SpudParser.DecimalsmallContext,0)


        def fractionsimple(self):
            return self.getTypedRuleContext(SpudParser.FractionsimpleContext,0)


        def fractioncomplex(self):
            return self.getTypedRuleContext(SpudParser.FractioncomplexContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_number

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

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




    def number(self):

        localctx = SpudParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_number)
        try:
            self.state = 183
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 178
                self.nonzerostring()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 179
                self.decimallarge()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 180
                self.decimalsmall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 181
                self.fractionsimple()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 182
                self.fractioncomplex()
                pass


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


    class OnelinecommentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_onelinecomment

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

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




    def onelinecomment(self):

        localctx = SpudParser.OnelinecommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_onelinecomment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 185
            _la = self._input.LA(1)
            if not(_la==SpudParser.T__2 or _la==SpudParser.T__3):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 189
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 186
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==SpudParser.Returnwhitespacetoken:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 191
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

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


    class MultilinecommentContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SpudParser.RULE_multilinecomment

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

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




    def multilinecomment(self):

        localctx = SpudParser.MultilinecommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_multilinecomment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.match(SpudParser.T__4)
            self.state = 196
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SpudParser.T__0) | (1 << SpudParser.T__1) | (1 << SpudParser.T__2) | (1 << SpudParser.T__3) | (1 << SpudParser.T__4) | (1 << SpudParser.T__6) | (1 << SpudParser.T__7) | (1 << SpudParser.T__8) | (1 << SpudParser.T__9) | (1 << SpudParser.T__10) | (1 << SpudParser.T__11) | (1 << SpudParser.T__12) | (1 << SpudParser.T__13) | (1 << SpudParser.T__14) | (1 << SpudParser.T__15) | (1 << SpudParser.T__16) | (1 << SpudParser.T__17) | (1 << SpudParser.T__18) | (1 << SpudParser.T__19) | (1 << SpudParser.T__20) | (1 << SpudParser.Inlinewhitespacetoken) | (1 << SpudParser.Returnwhitespacetoken) | (1 << SpudParser.Zerotoken) | (1 << SpudParser.Nonzerotoken) | (1 << SpudParser.Namesegment) | (1 << SpudParser.And) | (1 << SpudParser.Is) | (1 << SpudParser.Istype) | (1 << SpudParser.Issynonym) | (1 << SpudParser.Catchall))) != 0):
                self.state = 193
                _la = self._input.LA(1)
                if _la <= 0 or _la==SpudParser.T__5:
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 198
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 199
            self.match(SpudParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LinebreakContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Returnwhitespacetoken(self):
            return self.getToken(SpudParser.Returnwhitespacetoken, 0)

        def multilinecomment(self):
            return self.getTypedRuleContext(SpudParser.MultilinecommentContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_linebreak

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

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




    def linebreak(self):

        localctx = SpudParser.LinebreakContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_linebreak)
        try:
            self.state = 203
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.Returnwhitespacetoken]:
                self.enterOuterAlt(localctx, 1)
                self.state = 201
                self.match(SpudParser.Returnwhitespacetoken)
                pass
            elif token in [SpudParser.T__4]:
                self.enterOuterAlt(localctx, 2)
                self.state = 202
                self.multilinecomment()
                pass
            else:
                raise NoViableAltException(self)

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


    class PropspluselemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Namesegment(self):
            return self.getToken(SpudParser.Namesegment, 0)

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

        def getRuleIndex(self):
            return SpudParser.RULE_propspluselem

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

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




    def propspluselem(self):

        localctx = SpudParser.PropspluselemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_propspluselem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 205
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 210
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 211
            self.match(SpudParser.T__6)
            self.state = 215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 212
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 217
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 218
            self.match(SpudParser.Namesegment)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropsplusContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propspluselem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.PropspluselemContext)
            else:
                return self.getTypedRuleContext(SpudParser.PropspluselemContext,i)


        def getRuleIndex(self):
            return SpudParser.RULE_propsplus

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

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




    def propsplus(self):

        localctx = SpudParser.PropsplusContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_propsplus)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 223
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 220
                    self.propspluselem() 
                self.state = 225
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)

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


    class PropselemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Namesegment(self):
            return self.getToken(SpudParser.Namesegment, 0)

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

        def getRuleIndex(self):
            return SpudParser.RULE_propselem

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

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




    def propselem(self):

        localctx = SpudParser.PropselemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_propselem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 226
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 231
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 232
            _la = self._input.LA(1)
            if not(_la==SpudParser.T__6 or _la==SpudParser.T__7):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 236
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 233
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 238
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 239
            self.match(SpudParser.Namesegment)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propselem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.PropselemContext)
            else:
                return self.getTypedRuleContext(SpudParser.PropselemContext,i)


        def getRuleIndex(self):
            return SpudParser.RULE_props

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

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




    def props(self):

        localctx = SpudParser.PropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_props)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 241
                    self.propselem() 
                self.state = 246
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,self._ctx)

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


    class PropswildelemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_propswildelem

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

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




    def propswildelem(self):

        localctx = SpudParser.PropswildelemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_propswildelem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 250
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 247
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 252
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 253
            self.match(SpudParser.T__7)
            self.state = 257
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 254
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 259
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 260
            self.match(SpudParser.T__8)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropswildContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propselem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.PropselemContext)
            else:
                return self.getTypedRuleContext(SpudParser.PropselemContext,i)


        def propswildelem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.PropswildelemContext)
            else:
                return self.getTypedRuleContext(SpudParser.PropswildelemContext,i)


        def getRuleIndex(self):
            return SpudParser.RULE_propswild

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

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




    def propswild(self):

        localctx = SpudParser.PropswildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_propswild)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 266
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,20,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 264
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
                    if la_ == 1:
                        self.state = 262
                        self.propselem()
                        pass

                    elif la_ == 2:
                        self.state = 263
                        self.propswildelem()
                        pass

             
                self.state = 268
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,20,self._ctx)

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


    class BasicnameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_basicname

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

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




    def basicname(self):

        localctx = SpudParser.BasicnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_basicname)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 269
            self.match(SpudParser.Namesegment)
            self.state = 274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.T__0:
                self.state = 270
                self.match(SpudParser.T__0)
                self.state = 271
                self.match(SpudParser.Namesegment)
                self.state = 276
                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 BasicnamepluspropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicname(self):
            return self.getTypedRuleContext(SpudParser.BasicnameContext,0)


        def propsplus(self):
            return self.getTypedRuleContext(SpudParser.PropsplusContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_basicnameplusprops

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

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




    def basicnameplusprops(self):

        localctx = SpudParser.BasicnamepluspropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_basicnameplusprops)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 277
            self.basicname()
            self.state = 278
            self.propsplus()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineingredientContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicnameplusprops(self):
            return self.getTypedRuleContext(SpudParser.BasicnamepluspropsContext,0)


        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


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

        def basicname(self):
            return self.getTypedRuleContext(SpudParser.BasicnameContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_lineingredient

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

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




    def lineingredient(self):

        localctx = SpudParser.LineingredientContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_lineingredient)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SpudParser.T__0) | (1 << SpudParser.Zerotoken) | (1 << SpudParser.Nonzerotoken))) != 0):
                self.state = 280
                self.number()
                self.state = 282 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 281
                    self.match(SpudParser.Inlinewhitespacetoken)
                    self.state = 284 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SpudParser.Inlinewhitespacetoken):
                        break

                self.state = 292
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
                if la_ == 1:
                    self.state = 286
                    self.basicname()
                    self.state = 288 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 287
                        self.match(SpudParser.Inlinewhitespacetoken)
                        self.state = 290 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==SpudParser.Inlinewhitespacetoken):
                            break





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


    class PownameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicname(self):
            return self.getTypedRuleContext(SpudParser.BasicnameContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_powname

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

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




    def powname(self):

        localctx = SpudParser.PownameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_powname)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 299
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SpudParser.T__9:
                self.state = 298
                self.match(SpudParser.T__9)


            self.state = 301
            self.basicname()
            self.state = 303
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SpudParser.T__9:
                self.state = 302
                self.match(SpudParser.T__9)


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


    class PownamewithpropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def powname(self):
            return self.getTypedRuleContext(SpudParser.PownameContext,0)


        def props(self):
            return self.getTypedRuleContext(SpudParser.PropsContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_pownamewithprops

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

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




    def pownamewithprops(self):

        localctx = SpudParser.PownamewithpropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_pownamewithprops)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self.powname()
            self.state = 306
            self.props()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BasicnamewithpropswildContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicname(self):
            return self.getTypedRuleContext(SpudParser.BasicnameContext,0)


        def propswild(self):
            return self.getTypedRuleContext(SpudParser.PropswildContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_basicnamewithpropswild

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

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




    def basicnamewithpropswild(self):

        localctx = SpudParser.BasicnamewithpropswildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_basicnamewithpropswild)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.basicname()
            self.state = 309
            self.propswild()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WildcardwithpropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def props(self):
            return self.getTypedRuleContext(SpudParser.PropsContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_wildcardwithprops

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

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




    def wildcardwithprops(self):

        localctx = SpudParser.WildcardwithpropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_wildcardwithprops)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 311
            self.match(SpudParser.T__8)
            self.state = 312
            self.props()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WildcardwithpropswildContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propswild(self):
            return self.getTypedRuleContext(SpudParser.PropswildContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_wildcardwithpropswild

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

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




    def wildcardwithpropswild(self):

        localctx = SpudParser.WildcardwithpropswildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_wildcardwithpropswild)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self.match(SpudParser.T__8)
            self.state = 315
            self.propswild()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PowwildwithpropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pownamewithprops(self):
            return self.getTypedRuleContext(SpudParser.PownamewithpropsContext,0)


        def wildcardwithprops(self):
            return self.getTypedRuleContext(SpudParser.WildcardwithpropsContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_powwildwithprops

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

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




    def powwildwithprops(self):

        localctx = SpudParser.PowwildwithpropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_powwildwithprops)
        try:
            self.state = 319
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__9, SpudParser.Namesegment]:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.pownamewithprops()
                pass
            elif token in [SpudParser.T__8]:
                self.enterOuterAlt(localctx, 2)
                self.state = 318
                self.wildcardwithprops()
                pass
            else:
                raise NoViableAltException(self)

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


    class BasicwildwithpropsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicnamewithpropswild(self):
            return self.getTypedRuleContext(SpudParser.BasicnamewithpropswildContext,0)


        def wildcardwithpropswild(self):
            return self.getTypedRuleContext(SpudParser.WildcardwithpropswildContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_basicwildwithprops

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

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




    def basicwildwithprops(self):

        localctx = SpudParser.BasicwildwithpropsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_basicwildwithprops)
        try:
            self.state = 323
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.Namesegment]:
                self.enterOuterAlt(localctx, 1)
                self.state = 321
                self.basicnamewithpropswild()
                pass
            elif token in [SpudParser.T__8]:
                self.enterOuterAlt(localctx, 2)
                self.state = 322
                self.wildcardwithpropswild()
                pass
            else:
                raise NoViableAltException(self)

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


    class RuleleftsimpleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pownamewithprops(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.PownamewithpropsContext)
            else:
                return self.getTypedRuleContext(SpudParser.PownamewithpropsContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_ruleleftsimple

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

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




    def ruleleftsimple(self):

        localctx = SpudParser.RuleleftsimpleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_ruleleftsimple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 325
            self.pownamewithprops()
            self.state = 330
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 326
                self.match(SpudParser.And)
                self.state = 327
                self.pownamewithprops()
                self.state = 332
                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 RulerightsimpleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicnamewithpropswild(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.BasicnamewithpropswildContext)
            else:
                return self.getTypedRuleContext(SpudParser.BasicnamewithpropswildContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_rulerightsimple

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

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




    def rulerightsimple(self):

        localctx = SpudParser.RulerightsimpleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_rulerightsimple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.basicnamewithpropswild()
            self.state = 338
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 334
                self.match(SpudParser.And)
                self.state = 335
                self.basicnamewithpropswild()
                self.state = 340
                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 RulerightsimplewildContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicwildwithprops(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.BasicwildwithpropsContext)
            else:
                return self.getTypedRuleContext(SpudParser.BasicwildwithpropsContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_rulerightsimplewild

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

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




    def rulerightsimplewild(self):

        localctx = SpudParser.RulerightsimplewildContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_rulerightsimplewild)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 341
            self.basicwildwithprops()
            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 342
                self.match(SpudParser.And)
                self.state = 343
                self.basicwildwithprops()
                self.state = 348
                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 LinerenamingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ruleleftsimple(self):
            return self.getTypedRuleContext(SpudParser.RuleleftsimpleContext,0)


        def Is(self):
            return self.getToken(SpudParser.Is, 0)

        def rulerightsimplewild(self):
            return self.getTypedRuleContext(SpudParser.RulerightsimplewildContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_linerenaming

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

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




    def linerenaming(self):

        localctx = SpudParser.LinerenamingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_linerenaming)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            self.ruleleftsimple()
            self.state = 350
            self.match(SpudParser.Is)
            self.state = 351
            self.rulerightsimplewild()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineprefixingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ruleleftsimple(self):
            return self.getTypedRuleContext(SpudParser.RuleleftsimpleContext,0)


        def Istype(self):
            return self.getToken(SpudParser.Istype, 0)

        def rulerightsimplewild(self):
            return self.getTypedRuleContext(SpudParser.RulerightsimplewildContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_lineprefixing

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

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




    def lineprefixing(self):

        localctx = SpudParser.LineprefixingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_lineprefixing)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 353
            self.ruleleftsimple()
            self.state = 354
            self.match(SpudParser.Istype)
            self.state = 355
            self.rulerightsimplewild()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineinsertingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ruleleftsimple(self):
            return self.getTypedRuleContext(SpudParser.RuleleftsimpleContext,0)


        def Issynonym(self):
            return self.getToken(SpudParser.Issynonym, 0)

        def rulerightsimple(self):
            return self.getTypedRuleContext(SpudParser.RulerightsimpleContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_lineinserting

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

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




    def lineinserting(self):

        localctx = SpudParser.LineinsertingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_lineinserting)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 357
            self.ruleleftsimple()
            self.state = 358
            self.match(SpudParser.Issynonym)
            self.state = 359
            self.rulerightsimple()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SingleconvertingleftelemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


        def pownamewithprops(self):
            return self.getTypedRuleContext(SpudParser.PownamewithpropsContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_singleconvertingleftelem

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

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




    def singleconvertingleftelem(self):

        localctx = SpudParser.SingleconvertingleftelemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_singleconvertingleftelem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.number()
            self.state = 363 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 362
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 365 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class SingleconvertingrightelemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicwildwithprops(self):
            return self.getTypedRuleContext(SpudParser.BasicwildwithpropsContext,0)


        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_singleconvertingrightelem

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

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




    def singleconvertingrightelem(self):

        localctx = SpudParser.SingleconvertingrightelemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_singleconvertingrightelem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__0, SpudParser.Zerotoken, SpudParser.Nonzerotoken]:
                self.state = 369
                self.number()
                pass
            elif token in [SpudParser.T__8]:
                self.state = 370
                self.match(SpudParser.T__8)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 374 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 373
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 376 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class SingleconvertingleftContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def singleconvertingleftelem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.SingleconvertingleftelemContext)
            else:
                return self.getTypedRuleContext(SpudParser.SingleconvertingleftelemContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_singleconvertingleft

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

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




    def singleconvertingleft(self):

        localctx = SpudParser.SingleconvertingleftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_singleconvertingleft)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            self.singleconvertingleftelem()
            self.state = 385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 381
                self.match(SpudParser.And)
                self.state = 382
                self.singleconvertingleftelem()
                self.state = 387
                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 SingleconvertingrightContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def singleconvertingrightelem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.SingleconvertingrightelemContext)
            else:
                return self.getTypedRuleContext(SpudParser.SingleconvertingrightelemContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_singleconvertingright

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

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




    def singleconvertingright(self):

        localctx = SpudParser.SingleconvertingrightContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_singleconvertingright)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self.singleconvertingrightelem()
            self.state = 393
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 389
                self.match(SpudParser.And)
                self.state = 390
                self.singleconvertingrightelem()
                self.state = 395
                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 LinesingleconvertingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def singleconvertingleft(self):
            return self.getTypedRuleContext(SpudParser.SingleconvertingleftContext,0)


        def Is(self):
            return self.getToken(SpudParser.Is, 0)

        def singleconvertingright(self):
            return self.getTypedRuleContext(SpudParser.SingleconvertingrightContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_linesingleconverting

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

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




    def linesingleconverting(self):

        localctx = SpudParser.LinesingleconvertingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_linesingleconverting)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.singleconvertingleft()
            self.state = 397
            self.match(SpudParser.Is)
            self.state = 398
            self.singleconvertingright()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Doubleconvertingleftsub1Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def pownamewithprops(self):
            return self.getTypedRuleContext(SpudParser.PownamewithpropsContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingleftsub1

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

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




    def doubleconvertingleftsub1(self):

        localctx = SpudParser.Doubleconvertingleftsub1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_doubleconvertingleftsub1)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 400
            self.match(SpudParser.T__8)
            self.state = 402 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 401
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 404 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class Doubleconvertingleftsub2Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def powname(self):
            return self.getTypedRuleContext(SpudParser.PownameContext,0)


        def powwildwithprops(self):
            return self.getTypedRuleContext(SpudParser.PowwildwithpropsContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingleftsub2

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

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




    def doubleconvertingleftsub2(self):

        localctx = SpudParser.Doubleconvertingleftsub2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_doubleconvertingleftsub2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.powname()
            self.state = 410 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 409
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 412 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class DoubleconvertingleftelemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


        def doubleconvertingleftsub1(self):
            return self.getTypedRuleContext(SpudParser.Doubleconvertingleftsub1Context,0)


        def doubleconvertingleftsub2(self):
            return self.getTypedRuleContext(SpudParser.Doubleconvertingleftsub2Context,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingleftelem

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

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




    def doubleconvertingleftelem(self):

        localctx = SpudParser.DoubleconvertingleftelemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_doubleconvertingleftelem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 416
            self.number()
            self.state = 418 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 417
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 420 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 424
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__8]:
                self.state = 422
                self.doubleconvertingleftsub1()
                pass
            elif token in [SpudParser.T__9, SpudParser.Namesegment]:
                self.state = 423
                self.doubleconvertingleftsub2()
                pass
            else:
                raise NoViableAltException(self)

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


    class DoubleconvertingrightelemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def basicwildwithprops(self):
            return self.getTypedRuleContext(SpudParser.BasicwildwithpropsContext,0)


        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


        def basicname(self):
            return self.getTypedRuleContext(SpudParser.BasicnameContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingrightelem

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

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




    def doubleconvertingrightelem(self):

        localctx = SpudParser.DoubleconvertingrightelemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_doubleconvertingrightelem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__0, SpudParser.Zerotoken, SpudParser.Nonzerotoken]:
                self.state = 426
                self.number()
                pass
            elif token in [SpudParser.T__8]:
                self.state = 427
                self.match(SpudParser.T__8)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 431 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 430
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 433 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 437
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.Namesegment]:
                self.state = 435
                self.basicname()
                pass
            elif token in [SpudParser.T__8]:
                self.state = 436
                self.match(SpudParser.T__8)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 440 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 439
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 442 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class DoubleconvertingleftContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def doubleconvertingleftelem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.DoubleconvertingleftelemContext)
            else:
                return self.getTypedRuleContext(SpudParser.DoubleconvertingleftelemContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingleft

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

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




    def doubleconvertingleft(self):

        localctx = SpudParser.DoubleconvertingleftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_doubleconvertingleft)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 446
            self.doubleconvertingleftelem()
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 447
                self.match(SpudParser.And)
                self.state = 448
                self.doubleconvertingleftelem()
                self.state = 453
                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 DoubleconvertingrightContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def doubleconvertingrightelem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.DoubleconvertingrightelemContext)
            else:
                return self.getTypedRuleContext(SpudParser.DoubleconvertingrightelemContext,i)


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

        def getRuleIndex(self):
            return SpudParser.RULE_doubleconvertingright

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

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




    def doubleconvertingright(self):

        localctx = SpudParser.DoubleconvertingrightContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_doubleconvertingright)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self.doubleconvertingrightelem()
            self.state = 459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.And:
                self.state = 455
                self.match(SpudParser.And)
                self.state = 456
                self.doubleconvertingrightelem()
                self.state = 461
                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 LinedoubleconvertingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def doubleconvertingleft(self):
            return self.getTypedRuleContext(SpudParser.DoubleconvertingleftContext,0)


        def Is(self):
            return self.getToken(SpudParser.Is, 0)

        def doubleconvertingright(self):
            return self.getTypedRuleContext(SpudParser.DoubleconvertingrightContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_linedoubleconverting

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

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




    def linedoubleconverting(self):

        localctx = SpudParser.LinedoubleconvertingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_linedoubleconverting)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 462
            self.doubleconvertingleft()
            self.state = 463
            self.match(SpudParser.Is)
            self.state = 464
            self.doubleconvertingright()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LinestandardruleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def linerenaming(self):
            return self.getTypedRuleContext(SpudParser.LinerenamingContext,0)


        def lineprefixing(self):
            return self.getTypedRuleContext(SpudParser.LineprefixingContext,0)


        def lineinserting(self):
            return self.getTypedRuleContext(SpudParser.LineinsertingContext,0)


        def linesingleconverting(self):
            return self.getTypedRuleContext(SpudParser.LinesingleconvertingContext,0)


        def linedoubleconverting(self):
            return self.getTypedRuleContext(SpudParser.LinedoubleconvertingContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_linestandardrule

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

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




    def linestandardrule(self):

        localctx = SpudParser.LinestandardruleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_linestandardrule)
        try:
            self.state = 471
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 466
                self.linerenaming()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 467
                self.lineprefixing()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 468
                self.lineinserting()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 469
                self.linesingleconverting()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 470
                self.linedoubleconverting()
                pass


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


    class AtimportContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_atimport

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

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




    def atimport(self):

        localctx = SpudParser.AtimportContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_atimport)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self.match(SpudParser.T__10)
            self.state = 475 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 474
                    self.match(SpudParser.Inlinewhitespacetoken)

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

            self.state = 482
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,50,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 479
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==SpudParser.Returnwhitespacetoken:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 484
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,50,self._ctx)

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


    class AtrunContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_atrun

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

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




    def atrun(self):

        localctx = SpudParser.AtrunContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_atrun)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 485
            self.match(SpudParser.T__11)
            self.state = 487 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 486
                    self.match(SpudParser.Inlinewhitespacetoken)

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

            self.state = 494
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 491
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==SpudParser.Returnwhitespacetoken:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 496
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,52,self._ctx)

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


    class Atsub1Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def pownamewithprops(self):
            return self.getTypedRuleContext(SpudParser.PownamewithpropsContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_atsub1

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

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




    def atsub1(self):

        localctx = SpudParser.Atsub1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_atsub1)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 497
            self.match(SpudParser.T__8)
            self.state = 499 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 498
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 501 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class Atsub2Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def powname(self):
            return self.getTypedRuleContext(SpudParser.PownameContext,0)


        def powwildwithprops(self):
            return self.getTypedRuleContext(SpudParser.PowwildwithpropsContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_atsub2

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

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




    def atsub2(self):

        localctx = SpudParser.Atsub2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_atsub2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 505
            self.powname()
            self.state = 507 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 506
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 509 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 513
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 511
                self.powwildwithprops()
                pass

            elif la_ == 2:
                self.state = 512
                self.match(SpudParser.T__8)
                pass


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


    class AtsubContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atsub1(self):
            return self.getTypedRuleContext(SpudParser.Atsub1Context,0)


        def atsub2(self):
            return self.getTypedRuleContext(SpudParser.Atsub2Context,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_atsub

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

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




    def atsub(self):

        localctx = SpudParser.AtsubContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_atsub)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 516 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 515
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 518 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 522
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__8]:
                self.state = 520
                self.atsub1()
                pass
            elif token in [SpudParser.T__9, SpudParser.Namesegment]:
                self.state = 521
                self.atsub2()
                pass
            else:
                raise NoViableAltException(self)

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


    class AtholdContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atsub(self):
            return self.getTypedRuleContext(SpudParser.AtsubContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_athold

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

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




    def athold(self):

        localctx = SpudParser.AtholdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_athold)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524
            self.match(SpudParser.T__12)
            self.state = 525
            self.atsub()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtholdunitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atsub(self):
            return self.getTypedRuleContext(SpudParser.AtsubContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_atholdunit

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

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




    def atholdunit(self):

        localctx = SpudParser.AtholdunitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_atholdunit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self.match(SpudParser.T__13)
            self.state = 528
            self.atsub()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtdecContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atsub(self):
            return self.getTypedRuleContext(SpudParser.AtsubContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_atdec

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

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




    def atdec(self):

        localctx = SpudParser.AtdecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_atdec)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 530
            self.match(SpudParser.T__14)
            self.state = 531
            self.atsub()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtfracContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atsub(self):
            return self.getTypedRuleContext(SpudParser.AtsubContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_atfrac

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

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




    def atfrac(self):

        localctx = SpudParser.AtfracContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_atfrac)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 533
            self.match(SpudParser.T__15)
            self.state = 534
            self.atsub()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtbeginisolateContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SpudParser.RULE_atbeginisolate

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

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




    def atbeginisolate(self):

        localctx = SpudParser.AtbeginisolateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_atbeginisolate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.match(SpudParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtbeginmultiplyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def number(self):
            return self.getTypedRuleContext(SpudParser.NumberContext,0)


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

        def getRuleIndex(self):
            return SpudParser.RULE_atbeginmultiply

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

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




    def atbeginmultiply(self):

        localctx = SpudParser.AtbeginmultiplyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_atbeginmultiply)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.match(SpudParser.T__17)
            self.state = 540 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 539
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 542 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

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


    class AtbeginContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atbeginisolate(self):
            return self.getTypedRuleContext(SpudParser.AtbeginisolateContext,0)


        def atbeginmultiply(self):
            return self.getTypedRuleContext(SpudParser.AtbeginmultiplyContext,0)


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

        def onelinecomment(self):
            return self.getTypedRuleContext(SpudParser.OnelinecommentContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_atbegin

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

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




    def atbegin(self):

        localctx = SpudParser.AtbeginContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_atbegin)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(SpudParser.T__18)
            self.state = 548 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 547
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 550 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SpudParser.Inlinewhitespacetoken):
                    break

            self.state = 554
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__16]:
                self.state = 552
                self.atbeginisolate()
                pass
            elif token in [SpudParser.T__17]:
                self.state = 553
                self.atbeginmultiply()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 556
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 561
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SpudParser.T__2 or _la==SpudParser.T__3:
                self.state = 562
                self.onelinecomment()


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


    class AtendContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_atend

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

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




    def atend(self):

        localctx = SpudParser.AtendContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_atend)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 565
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 570
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 571
            self.match(SpudParser.T__19)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtsectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atbegin(self):
            return self.getTypedRuleContext(SpudParser.AtbeginContext,0)


        def linebreak(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.LinebreakContext)
            else:
                return self.getTypedRuleContext(SpudParser.LinebreakContext,i)


        def atend(self):
            return self.getTypedRuleContext(SpudParser.AtendContext,0)


        def line(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.LineContext)
            else:
                return self.getTypedRuleContext(SpudParser.LineContext,i)


        def getRuleIndex(self):
            return SpudParser.RULE_atsection

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

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




    def atsection(self):

        localctx = SpudParser.AtsectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_atsection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self.atbegin()
            self.state = 574
            self.linebreak()
            self.state = 580
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,64,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 575
                    self.line()
                    self.state = 576
                    self.linebreak() 
                self.state = 582
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,64,self._ctx)

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


    class LineatContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atimport(self):
            return self.getTypedRuleContext(SpudParser.AtimportContext,0)


        def atrun(self):
            return self.getTypedRuleContext(SpudParser.AtrunContext,0)


        def athold(self):
            return self.getTypedRuleContext(SpudParser.AtholdContext,0)


        def atholdunit(self):
            return self.getTypedRuleContext(SpudParser.AtholdunitContext,0)


        def atdec(self):
            return self.getTypedRuleContext(SpudParser.AtdecContext,0)


        def atfrac(self):
            return self.getTypedRuleContext(SpudParser.AtfracContext,0)


        def atsection(self):
            return self.getTypedRuleContext(SpudParser.AtsectionContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_lineat

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

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




    def lineat(self):

        localctx = SpudParser.LineatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_lineat)
        try:
            self.state = 592
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SpudParser.T__10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 585
                self.atimport()
                pass
            elif token in [SpudParser.T__11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 586
                self.atrun()
                pass
            elif token in [SpudParser.T__12]:
                self.enterOuterAlt(localctx, 3)
                self.state = 587
                self.athold()
                pass
            elif token in [SpudParser.T__13]:
                self.enterOuterAlt(localctx, 4)
                self.state = 588
                self.atholdunit()
                pass
            elif token in [SpudParser.T__14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 589
                self.atdec()
                pass
            elif token in [SpudParser.T__15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 590
                self.atfrac()
                pass
            elif token in [SpudParser.T__18]:
                self.enterOuterAlt(localctx, 7)
                self.state = 591
                self.atsection()
                pass
            else:
                raise NoViableAltException(self)

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


    class VerisoncontrolContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SpudParser.RULE_verisoncontrol

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

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




    def verisoncontrol(self):

        localctx = SpudParser.VerisoncontrolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_verisoncontrol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 594
            self.match(SpudParser.T__20)
            self.state = 598
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 595
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==SpudParser.Returnwhitespacetoken:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 600
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

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


    class LineContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def onelinecomment(self):
            return self.getTypedRuleContext(SpudParser.OnelinecommentContext,0)


        def lineingredient(self):
            return self.getTypedRuleContext(SpudParser.LineingredientContext,0)


        def linestandardrule(self):
            return self.getTypedRuleContext(SpudParser.LinestandardruleContext,0)


        def lineat(self):
            return self.getTypedRuleContext(SpudParser.LineatContext,0)


        def verisoncontrol(self):
            return self.getTypedRuleContext(SpudParser.VerisoncontrolContext,0)


        def getRuleIndex(self):
            return SpudParser.RULE_line

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

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




    def line(self):

        localctx = SpudParser.LineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_line)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SpudParser.Inlinewhitespacetoken:
                self.state = 601
                self.match(SpudParser.Inlinewhitespacetoken)
                self.state = 606
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SpudParser.T__0) | (1 << SpudParser.T__9) | (1 << SpudParser.T__10) | (1 << SpudParser.T__11) | (1 << SpudParser.T__12) | (1 << SpudParser.T__13) | (1 << SpudParser.T__14) | (1 << SpudParser.T__15) | (1 << SpudParser.T__18) | (1 << SpudParser.T__20) | (1 << SpudParser.Zerotoken) | (1 << SpudParser.Nonzerotoken) | (1 << SpudParser.Namesegment))) != 0):
                self.state = 611
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 607
                    self.lineingredient()
                    pass

                elif la_ == 2:
                    self.state = 608
                    self.linestandardrule()
                    pass

                elif la_ == 3:
                    self.state = 609
                    self.lineat()
                    pass

                elif la_ == 4:
                    self.state = 610
                    self.verisoncontrol()
                    pass


                self.state = 616
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SpudParser.Inlinewhitespacetoken:
                    self.state = 613
                    self.match(SpudParser.Inlinewhitespacetoken)
                    self.state = 618
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SpudParser.T__2 or _la==SpudParser.T__3:
                self.state = 621
                self.onelinecomment()


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


    class SpudContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def line(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.LineContext)
            else:
                return self.getTypedRuleContext(SpudParser.LineContext,i)


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

        def linebreak(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SpudParser.LinebreakContext)
            else:
                return self.getTypedRuleContext(SpudParser.LinebreakContext,i)


        def getRuleIndex(self):
            return SpudParser.RULE_spud

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

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




    def spud(self):

        localctx = SpudParser.SpudContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_spud)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 629
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,72,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 624
                    self.line()
                    self.state = 625
                    self.linebreak() 
                self.state = 631
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,72,self._ctx)

            self.state = 632
            self.line()
            self.state = 633
            self.match(SpudParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





