# Generated from CommentMacro.g4 by ANTLR 4.9.1
# 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\62")
        buf.write("\u0111\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\3\2\7\2\26\n\2\f\2\16\2\31\13")
        buf.write("\2\3\2\3\2\3\3\3\3\3\3\7\3 \n\3\f\3\16\3#\13\3\3\3\5\3")
        buf.write("&\n\3\3\3\5\3)\n\3\3\4\3\4\3\4\5\4.\n\4\3\4\5\4\61\n\4")
        buf.write("\3\4\3\4\3\4\5\4\66\n\4\3\4\3\4\3\4\5\4;\n\4\3\4\3\4\3")
        buf.write("\4\5\4@\n\4\3\4\5\4C\n\4\3\4\3\4\3\4\5\4H\n\4\3\4\5\4")
        buf.write("K\n\4\3\4\3\4\3\4\5\4P\n\4\3\4\5\4S\n\4\3\4\3\4\5\4W\n")
        buf.write("\4\3\4\3\4\5\4[\n\4\3\4\3\4\3\4\5\4`\n\4\3\4\3\4\3\4\5")
        buf.write("\4e\n\4\3\4\5\4h\n\4\3\4\3\4\3\4\5\4m\n\4\3\4\5\4p\n\4")
        buf.write("\3\4\3\4\3\4\5\4u\n\4\3\4\3\4\3\4\5\4z\n\4\3\4\3\4\3\4")
        buf.write("\3\4\3\4\5\4\u0081\n\4\3\4\3\4\3\4\5\4\u0086\n\4\3\4\3")
        buf.write("\4\3\4\5\4\u008b\n\4\3\4\3\4\3\4\5\4\u0090\n\4\3\4\3\4")
        buf.write("\3\4\5\4\u0095\n\4\3\4\3\4\3\4\5\4\u009a\n\4\3\4\3\4\3")
        buf.write("\4\5\4\u009f\n\4\3\4\3\4\3\4\5\4\u00a4\n\4\3\4\3\4\3\4")
        buf.write("\5\4\u00a9\n\4\3\4\3\4\3\4\5\4\u00ae\n\4\3\4\3\4\3\4\5")
        buf.write("\4\u00b3\n\4\3\4\3\4\3\4\5\4\u00b8\n\4\3\4\3\4\3\4\5\4")
        buf.write("\u00bd\n\4\3\4\3\4\3\4\5\4\u00c2\n\4\3\4\3\4\3\4\5\4\u00c7")
        buf.write("\n\4\3\4\3\4\3\4\5\4\u00cc\n\4\3\4\3\4\3\4\3\4\3\4\5\4")
        buf.write("\u00d3\n\4\3\4\3\4\3\4\5\4\u00d8\n\4\3\4\3\4\3\4\5\4\u00dd")
        buf.write("\n\4\3\4\3\4\3\4\5\4\u00e2\n\4\3\4\3\4\3\4\5\4\u00e7\n")
        buf.write("\4\3\4\3\4\3\4\5\4\u00ec\n\4\3\4\3\4\3\4\5\4\u00f1\n\4")
        buf.write("\3\4\3\4\3\4\5\4\u00f6\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7")
        buf.write("\3\7\3\b\3\b\5\b\u0102\n\b\3\b\3\b\7\b\u0106\n\b\f\b\16")
        buf.write("\b\u0109\13\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\2\2\13\2\4\6")
        buf.write("\b\n\f\16\20\22\2\3\3\2-/\2\u015b\2\27\3\2\2\2\4(\3\2")
        buf.write("\2\2\6\u00f5\3\2\2\2\b\u00f7\3\2\2\2\n\u00fa\3\2\2\2\f")
        buf.write("\u00fd\3\2\2\2\16\u0101\3\2\2\2\20\u010a\3\2\2\2\22\u010e")
        buf.write("\3\2\2\2\24\26\5\4\3\2\25\24\3\2\2\2\26\31\3\2\2\2\27")
        buf.write("\25\3\2\2\2\27\30\3\2\2\2\30\32\3\2\2\2\31\27\3\2\2\2")
        buf.write("\32\33\7\2\2\3\33\3\3\2\2\2\34!\5\6\4\2\35\36\7\3\2\2")
        buf.write("\36 \5\6\4\2\37\35\3\2\2\2 #\3\2\2\2!\37\3\2\2\2!\"\3")
        buf.write("\2\2\2\"%\3\2\2\2#!\3\2\2\2$&\7\60\2\2%$\3\2\2\2%&\3\2")
        buf.write("\2\2&)\3\2\2\2\')\7\60\2\2(\34\3\2\2\2(\'\3\2\2\2)\5\3")
        buf.write("\2\2\2*-\7\4\2\2+.\5\16\b\2,.\7+\2\2-+\3\2\2\2-,\3\2\2")
        buf.write("\2.\60\3\2\2\2/\61\5\n\6\2\60/\3\2\2\2\60\61\3\2\2\2\61")
        buf.write("\u00f6\3\2\2\2\62\65\7\4\2\2\63\66\5\16\b\2\64\66\7+\2")
        buf.write("\2\65\63\3\2\2\2\65\64\3\2\2\2\66\67\3\2\2\2\678\7\5\2")
        buf.write("\28:\5\22\n\29;\5\n\6\2:9\3\2\2\2:;\3\2\2\2;\u00f6\3\2")
        buf.write("\2\2<?\7\6\2\2=@\5\16\b\2>@\7+\2\2?=\3\2\2\2?>\3\2\2\2")
        buf.write("@B\3\2\2\2AC\5\n\6\2BA\3\2\2\2BC\3\2\2\2C\u00f6\3\2\2")
        buf.write("\2DG\7\7\2\2EH\5\16\b\2FH\7+\2\2GE\3\2\2\2GF\3\2\2\2H")
        buf.write("J\3\2\2\2IK\5\n\6\2JI\3\2\2\2JK\3\2\2\2K\u00f6\3\2\2\2")
        buf.write("LO\7\b\2\2MP\5\16\b\2NP\7+\2\2OM\3\2\2\2ON\3\2\2\2PR\3")
        buf.write("\2\2\2QS\5\n\6\2RQ\3\2\2\2RS\3\2\2\2S\u00f6\3\2\2\2TV")
        buf.write("\7\t\2\2UW\5\n\6\2VU\3\2\2\2VW\3\2\2\2W\u00f6\3\2\2\2")
        buf.write("XZ\7\n\2\2Y[\5\n\6\2ZY\3\2\2\2Z[\3\2\2\2[\u00f6\3\2\2")
        buf.write("\2\\_\7\13\2\2]`\5\16\b\2^`\7+\2\2_]\3\2\2\2_^\3\2\2\2")
        buf.write("`a\3\2\2\2ab\7\5\2\2bd\5\22\n\2ce\5\b\5\2dc\3\2\2\2de")
        buf.write("\3\2\2\2eg\3\2\2\2fh\5\n\6\2gf\3\2\2\2gh\3\2\2\2h\u00f6")
        buf.write("\3\2\2\2ij\7\f\2\2jl\5\22\n\2km\5\b\5\2lk\3\2\2\2lm\3")
        buf.write("\2\2\2mo\3\2\2\2np\5\n\6\2on\3\2\2\2op\3\2\2\2p\u00f6")
        buf.write("\3\2\2\2qr\7\r\2\2rt\5\22\n\2su\5\n\6\2ts\3\2\2\2tu\3")
        buf.write("\2\2\2u\u00f6\3\2\2\2vw\7\16\2\2wy\5\16\b\2xz\5\n\6\2")
        buf.write("yx\3\2\2\2yz\3\2\2\2z\u00f6\3\2\2\2{|\7\16\2\2|}\5\16")
        buf.write("\b\2}~\7\5\2\2~\u0080\5\22\n\2\177\u0081\5\n\6\2\u0080")
        buf.write("\177\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u00f6\3\2\2\2\u0082")
        buf.write("\u0083\7\17\2\2\u0083\u0085\5\16\b\2\u0084\u0086\5\n\6")
        buf.write("\2\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u00f6")
        buf.write("\3\2\2\2\u0087\u0088\7\20\2\2\u0088\u008a\5\16\b\2\u0089")
        buf.write("\u008b\5\n\6\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2\2")
        buf.write("\u008b\u00f6\3\2\2\2\u008c\u008d\7\21\2\2\u008d\u008f")
        buf.write("\5\16\b\2\u008e\u0090\5\n\6\2\u008f\u008e\3\2\2\2\u008f")
        buf.write("\u0090\3\2\2\2\u0090\u00f6\3\2\2\2\u0091\u0092\7\22\2")
        buf.write("\2\u0092\u0094\5\16\b\2\u0093\u0095\5\n\6\2\u0094\u0093")
        buf.write("\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u00f6\3\2\2\2\u0096")
        buf.write("\u0097\7\23\2\2\u0097\u0099\5\16\b\2\u0098\u009a\5\n\6")
        buf.write("\2\u0099\u0098\3\2\2\2\u0099\u009a\3\2\2\2\u009a\u00f6")
        buf.write("\3\2\2\2\u009b\u009c\7\24\2\2\u009c\u009e\5\16\b\2\u009d")
        buf.write("\u009f\5\n\6\2\u009e\u009d\3\2\2\2\u009e\u009f\3\2\2\2")
        buf.write("\u009f\u00f6\3\2\2\2\u00a0\u00a1\7\25\2\2\u00a1\u00a3")
        buf.write("\5\16\b\2\u00a2\u00a4\5\n\6\2\u00a3\u00a2\3\2\2\2\u00a3")
        buf.write("\u00a4\3\2\2\2\u00a4\u00f6\3\2\2\2\u00a5\u00a6\7\26\2")
        buf.write("\2\u00a6\u00a8\5\16\b\2\u00a7\u00a9\5\n\6\2\u00a8\u00a7")
        buf.write("\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00f6\3\2\2\2\u00aa")
        buf.write("\u00ab\7\27\2\2\u00ab\u00ad\5\16\b\2\u00ac\u00ae\5\n\6")
        buf.write("\2\u00ad\u00ac\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00f6")
        buf.write("\3\2\2\2\u00af\u00b0\7\30\2\2\u00b0\u00b2\5\16\b\2\u00b1")
        buf.write("\u00b3\5\n\6\2\u00b2\u00b1\3\2\2\2\u00b2\u00b3\3\2\2\2")
        buf.write("\u00b3\u00f6\3\2\2\2\u00b4\u00b5\7\31\2\2\u00b5\u00b7")
        buf.write("\5\16\b\2\u00b6\u00b8\5\n\6\2\u00b7\u00b6\3\2\2\2\u00b7")
        buf.write("\u00b8\3\2\2\2\u00b8\u00f6\3\2\2\2\u00b9\u00ba\7\32\2")
        buf.write("\2\u00ba\u00bc\5\22\n\2\u00bb\u00bd\5\n\6\2\u00bc\u00bb")
        buf.write("\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00f6\3\2\2\2\u00be")
        buf.write("\u00bf\7\32\2\2\u00bf\u00c1\7\33\2\2\u00c0\u00c2\5\n\6")
        buf.write("\2\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00f6")
        buf.write("\3\2\2\2\u00c3\u00c4\7\32\2\2\u00c4\u00c6\7\34\2\2\u00c5")
        buf.write("\u00c7\5\n\6\2\u00c6\u00c5\3\2\2\2\u00c6\u00c7\3\2\2\2")
        buf.write("\u00c7\u00f6\3\2\2\2\u00c8\u00c9\7\35\2\2\u00c9\u00cb")
        buf.write("\5\22\n\2\u00ca\u00cc\5\n\6\2\u00cb\u00ca\3\2\2\2\u00cb")
        buf.write("\u00cc\3\2\2\2\u00cc\u00f6\3\2\2\2\u00cd\u00ce\7\36\2")
        buf.write("\2\u00ce\u00f6\5\n\6\2\u00cf\u00d0\7\37\2\2\u00d0\u00d2")
        buf.write("\5\16\b\2\u00d1\u00d3\5\n\6\2\u00d2\u00d1\3\2\2\2\u00d2")
        buf.write("\u00d3\3\2\2\2\u00d3\u00f6\3\2\2\2\u00d4\u00d5\7 \2\2")
        buf.write("\u00d5\u00d7\5\16\b\2\u00d6\u00d8\5\n\6\2\u00d7\u00d6")
        buf.write("\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00f6\3\2\2\2\u00d9")
        buf.write("\u00da\7!\2\2\u00da\u00dc\5\16\b\2\u00db\u00dd\5\n\6\2")
        buf.write("\u00dc\u00db\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00f6\3")
        buf.write("\2\2\2\u00de\u00df\7\"\2\2\u00df\u00e1\5\22\n\2\u00e0")
        buf.write("\u00e2\5\n\6\2\u00e1\u00e0\3\2\2\2\u00e1\u00e2\3\2\2\2")
        buf.write("\u00e2\u00f6\3\2\2\2\u00e3\u00e4\7#\2\2\u00e4\u00e6\5")
        buf.write("\22\n\2\u00e5\u00e7\5\n\6\2\u00e6\u00e5\3\2\2\2\u00e6")
        buf.write("\u00e7\3\2\2\2\u00e7\u00f6\3\2\2\2\u00e8\u00e9\7$\2\2")
        buf.write("\u00e9\u00eb\5\22\n\2\u00ea\u00ec\5\n\6\2\u00eb\u00ea")
        buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00f6\3\2\2\2\u00ed")
        buf.write("\u00ee\7%\2\2\u00ee\u00f0\5\22\n\2\u00ef\u00f1\5\n\6\2")
        buf.write("\u00f0\u00ef\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f6\3")
        buf.write("\2\2\2\u00f2\u00f3\7&\2\2\u00f3\u00f6\5\22\n\2\u00f4\u00f6")
        buf.write("\7\'\2\2\u00f5*\3\2\2\2\u00f5\62\3\2\2\2\u00f5<\3\2\2")
        buf.write("\2\u00f5D\3\2\2\2\u00f5L\3\2\2\2\u00f5T\3\2\2\2\u00f5")
        buf.write("X\3\2\2\2\u00f5\\\3\2\2\2\u00f5i\3\2\2\2\u00f5q\3\2\2")
        buf.write("\2\u00f5v\3\2\2\2\u00f5{\3\2\2\2\u00f5\u0082\3\2\2\2\u00f5")
        buf.write("\u0087\3\2\2\2\u00f5\u008c\3\2\2\2\u00f5\u0091\3\2\2\2")
        buf.write("\u00f5\u0096\3\2\2\2\u00f5\u009b\3\2\2\2\u00f5\u00a0\3")
        buf.write("\2\2\2\u00f5\u00a5\3\2\2\2\u00f5\u00aa\3\2\2\2\u00f5\u00af")
        buf.write("\3\2\2\2\u00f5\u00b4\3\2\2\2\u00f5\u00b9\3\2\2\2\u00f5")
        buf.write("\u00be\3\2\2\2\u00f5\u00c3\3\2\2\2\u00f5\u00c8\3\2\2\2")
        buf.write("\u00f5\u00cd\3\2\2\2\u00f5\u00cf\3\2\2\2\u00f5\u00d4\3")
        buf.write("\2\2\2\u00f5\u00d9\3\2\2\2\u00f5\u00de\3\2\2\2\u00f5\u00e3")
        buf.write("\3\2\2\2\u00f5\u00e8\3\2\2\2\u00f5\u00ed\3\2\2\2\u00f5")
        buf.write("\u00f2\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\7\3\2\2\2\u00f7")
        buf.write("\u00f8\7,\2\2\u00f8\u00f9\5\22\n\2\u00f9\t\3\2\2\2\u00fa")
        buf.write("\u00fb\5\f\7\2\u00fb\u00fc\5\22\n\2\u00fc\13\3\2\2\2\u00fd")
        buf.write("\u00fe\t\2\2\2\u00fe\r\3\2\2\2\u00ff\u0102\5\22\n\2\u0100")
        buf.write("\u0102\5\20\t\2\u0101\u00ff\3\2\2\2\u0101\u0100\3\2\2")
        buf.write("\2\u0102\u0107\3\2\2\2\u0103\u0104\7(\2\2\u0104\u0106")
        buf.write("\5\16\b\2\u0105\u0103\3\2\2\2\u0106\u0109\3\2\2\2\u0107")
        buf.write("\u0105\3\2\2\2\u0107\u0108\3\2\2\2\u0108\17\3\2\2\2\u0109")
        buf.write("\u0107\3\2\2\2\u010a\u010b\5\22\n\2\u010b\u010c\7*\2\2")
        buf.write("\u010c\u010d\5\22\n\2\u010d\21\3\2\2\2\u010e\u010f\7)")
        buf.write("\2\2\u010f\23\3\2\2\2\63\27!%(-\60\65:?BGJORVZ_dgloty")
        buf.write("\u0080\u0085\u008a\u008f\u0094\u0099\u009e\u00a3\u00a8")
        buf.write("\u00ad\u00b2\u00b7\u00bc\u00c1\u00c6\u00cb\u00d2\u00d7")
        buf.write("\u00dc\u00e1\u00e6\u00eb\u00f0\u00f5\u0101\u0107")
        return buf.getvalue()


class CommentMacroParser ( Parser ):

    grammarFileName = "CommentMacro.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "':'", "'GM'", "'/'", "'HM'", "'AM'", 
                     "'RM'", "'RA'", "'RO'", "'FM'", "'FGM'", "'CM'", "'GL'", 
                     "'HL'", "'AL'", "'RL'", "'GB'", "'HB'", "'AB'", "'RB'", 
                     "'GS'", "'HS'", "'AS'", "'RS'", "'CP'", "'+'", "'-'", 
                     "'RV'", "'RN'", "'GK'", "'HK'", "'RK'", "'INT'", "'POS'", 
                     "'COLR'", "'BEAM'", "'WAIT'", "'PASS'", "','", "<INVALID>", 
                     "'>'", "'*'", "'t'", "<INVALID>", "<INVALID>", "'IOP'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "NUMBER", "THRU", 
                      "CURRENT", "TIME", "WHOLEHOG", "DP8K", "IOP", "NEWLINE", 
                      "WS", "COMMENT" ]

    RULE_prog = 0
    RULE_statement = 1
    RULE_macro = 2
    RULE_time = 3
    RULE_device = 4
    RULE_nodeType = 5
    RULE_target = 6
    RULE_span = 7
    RULE_number = 8

    ruleNames =  [ "prog", "statement", "macro", "time", "device", "nodeType", 
                   "target", "span", "number" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    NUMBER=39
    THRU=40
    CURRENT=41
    TIME=42
    WHOLEHOG=43
    DP8K=44
    IOP=45
    NEWLINE=46
    WS=47
    COMMENT=48

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




    class ProgContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return CommentMacroParser.RULE_prog

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

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




    def prog(self):

        localctx = CommentMacroParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_prog)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 21
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.T__1) | (1 << CommentMacroParser.T__3) | (1 << CommentMacroParser.T__4) | (1 << CommentMacroParser.T__5) | (1 << CommentMacroParser.T__6) | (1 << CommentMacroParser.T__7) | (1 << CommentMacroParser.T__8) | (1 << CommentMacroParser.T__9) | (1 << CommentMacroParser.T__10) | (1 << CommentMacroParser.T__11) | (1 << CommentMacroParser.T__12) | (1 << CommentMacroParser.T__13) | (1 << CommentMacroParser.T__14) | (1 << CommentMacroParser.T__15) | (1 << CommentMacroParser.T__16) | (1 << CommentMacroParser.T__17) | (1 << CommentMacroParser.T__18) | (1 << CommentMacroParser.T__19) | (1 << CommentMacroParser.T__20) | (1 << CommentMacroParser.T__21) | (1 << CommentMacroParser.T__22) | (1 << CommentMacroParser.T__23) | (1 << CommentMacroParser.T__26) | (1 << CommentMacroParser.T__27) | (1 << CommentMacroParser.T__28) | (1 << CommentMacroParser.T__29) | (1 << CommentMacroParser.T__30) | (1 << CommentMacroParser.T__31) | (1 << CommentMacroParser.T__32) | (1 << CommentMacroParser.T__33) | (1 << CommentMacroParser.T__34) | (1 << CommentMacroParser.T__35) | (1 << CommentMacroParser.T__36) | (1 << CommentMacroParser.NEWLINE))) != 0):
                self.state = 18
                self.statement()
                self.state = 23
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def macro(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CommentMacroParser.MacroContext)
            else:
                return self.getTypedRuleContext(CommentMacroParser.MacroContext,i)


        def NEWLINE(self):
            return self.getToken(CommentMacroParser.NEWLINE, 0)

        def getRuleIndex(self):
            return CommentMacroParser.RULE_statement

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

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




    def statement(self):

        localctx = CommentMacroParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 38
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CommentMacroParser.T__1, CommentMacroParser.T__3, CommentMacroParser.T__4, CommentMacroParser.T__5, CommentMacroParser.T__6, CommentMacroParser.T__7, CommentMacroParser.T__8, CommentMacroParser.T__9, CommentMacroParser.T__10, CommentMacroParser.T__11, CommentMacroParser.T__12, CommentMacroParser.T__13, CommentMacroParser.T__14, CommentMacroParser.T__15, CommentMacroParser.T__16, CommentMacroParser.T__17, CommentMacroParser.T__18, CommentMacroParser.T__19, CommentMacroParser.T__20, CommentMacroParser.T__21, CommentMacroParser.T__22, CommentMacroParser.T__23, CommentMacroParser.T__26, CommentMacroParser.T__27, CommentMacroParser.T__28, CommentMacroParser.T__29, CommentMacroParser.T__30, CommentMacroParser.T__31, CommentMacroParser.T__32, CommentMacroParser.T__33, CommentMacroParser.T__34, CommentMacroParser.T__35, CommentMacroParser.T__36]:
                self.enterOuterAlt(localctx, 1)
                self.state = 26
                self.macro()
                self.state = 31
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CommentMacroParser.T__0:
                    self.state = 27
                    self.match(CommentMacroParser.T__0)
                    self.state = 28
                    self.macro()
                    self.state = 33
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 35
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                if la_ == 1:
                    self.state = 34
                    self.match(CommentMacroParser.NEWLINE)


                pass
            elif token in [CommentMacroParser.NEWLINE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 37
                self.match(CommentMacroParser.NEWLINE)
                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 MacroContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CommentMacroParser.RULE_macro

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SceneReleaseContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterAssertContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterGotoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ListGotoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SceneAssertContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class RecallViewContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterGoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SceneHaltContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterChooseContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class BatchGoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class PagePrevContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SelectColourContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class PageNextContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ListReleseContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class PassContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)


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

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


    class ListHaltContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ReleaseAllContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SelectIntensityContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MacroGoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterReleaseContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterFadeContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def time(self):
            return self.getTypedRuleContext(CommentMacroParser.TimeContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class BatchAssertContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MasterHaltContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def CURRENT(self):
            return self.getToken(CommentMacroParser.CURRENT, 0)
        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SceneGoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ListAssertContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ListGoContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class BatchReleaseContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class FadeGrandMasterContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def time(self):
            return self.getTypedRuleContext(CommentMacroParser.TimeContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class BatchHaltContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MacroStopContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class PageChangeContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class NodeResetContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class SelectPositionContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class ReleaseOthersContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class MacroHaltContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def target(self):
            return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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


    class WaitContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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


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

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


    class SelectBeamContext(MacroContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def device(self):
            return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)


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

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



    def macro(self):

        localctx = CommentMacroParser.MacroContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_macro)
        self._la = 0 # Token type
        try:
            self.state = 243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                localctx = CommentMacroParser.MasterGoContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 40
                self.match(CommentMacroParser.T__1)
                self.state = 43
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 41
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 42
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 46
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 45
                    self.device()


                pass

            elif la_ == 2:
                localctx = CommentMacroParser.MasterGotoContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 48
                self.match(CommentMacroParser.T__1)
                self.state = 51
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 49
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 50
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 53
                self.match(CommentMacroParser.T__2)
                self.state = 54
                self.number()
                self.state = 56
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 55
                    self.device()


                pass

            elif la_ == 3:
                localctx = CommentMacroParser.MasterHaltContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 58
                self.match(CommentMacroParser.T__3)
                self.state = 61
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 59
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 60
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 64
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 63
                    self.device()


                pass

            elif la_ == 4:
                localctx = CommentMacroParser.MasterAssertContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 66
                self.match(CommentMacroParser.T__4)
                self.state = 69
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 67
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 68
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 72
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 71
                    self.device()


                pass

            elif la_ == 5:
                localctx = CommentMacroParser.MasterReleaseContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 74
                self.match(CommentMacroParser.T__5)
                self.state = 77
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 75
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 76
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 80
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 79
                    self.device()


                pass

            elif la_ == 6:
                localctx = CommentMacroParser.ReleaseAllContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 82
                self.match(CommentMacroParser.T__6)
                self.state = 84
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 83
                    self.device()


                pass

            elif la_ == 7:
                localctx = CommentMacroParser.ReleaseOthersContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 86
                self.match(CommentMacroParser.T__7)
                self.state = 88
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 87
                    self.device()


                pass

            elif la_ == 8:
                localctx = CommentMacroParser.MasterFadeContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 90
                self.match(CommentMacroParser.T__8)
                self.state = 93
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CommentMacroParser.NUMBER]:
                    self.state = 91
                    self.target()
                    pass
                elif token in [CommentMacroParser.CURRENT]:
                    self.state = 92
                    self.match(CommentMacroParser.CURRENT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 95
                self.match(CommentMacroParser.T__2)
                self.state = 96
                self.number()
                self.state = 98
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CommentMacroParser.TIME:
                    self.state = 97
                    self.time()


                self.state = 101
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 100
                    self.device()


                pass

            elif la_ == 9:
                localctx = CommentMacroParser.FadeGrandMasterContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 103
                self.match(CommentMacroParser.T__9)
                self.state = 104
                self.number()
                self.state = 106
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CommentMacroParser.TIME:
                    self.state = 105
                    self.time()


                self.state = 109
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 108
                    self.device()


                pass

            elif la_ == 10:
                localctx = CommentMacroParser.MasterChooseContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 111
                self.match(CommentMacroParser.T__10)
                self.state = 112
                self.number()
                self.state = 114
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 113
                    self.device()


                pass

            elif la_ == 11:
                localctx = CommentMacroParser.ListGoContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 116
                self.match(CommentMacroParser.T__11)
                self.state = 117
                self.target()
                self.state = 119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 118
                    self.device()


                pass

            elif la_ == 12:
                localctx = CommentMacroParser.ListGotoContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 121
                self.match(CommentMacroParser.T__11)
                self.state = 122
                self.target()
                self.state = 123
                self.match(CommentMacroParser.T__2)
                self.state = 124
                self.number()
                self.state = 126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 125
                    self.device()


                pass

            elif la_ == 13:
                localctx = CommentMacroParser.ListHaltContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 128
                self.match(CommentMacroParser.T__12)
                self.state = 129
                self.target()
                self.state = 131
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 130
                    self.device()


                pass

            elif la_ == 14:
                localctx = CommentMacroParser.ListAssertContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 133
                self.match(CommentMacroParser.T__13)
                self.state = 134
                self.target()
                self.state = 136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 135
                    self.device()


                pass

            elif la_ == 15:
                localctx = CommentMacroParser.ListReleseContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 138
                self.match(CommentMacroParser.T__14)
                self.state = 139
                self.target()
                self.state = 141
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 140
                    self.device()


                pass

            elif la_ == 16:
                localctx = CommentMacroParser.BatchGoContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 143
                self.match(CommentMacroParser.T__15)
                self.state = 144
                self.target()
                self.state = 146
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 145
                    self.device()


                pass

            elif la_ == 17:
                localctx = CommentMacroParser.BatchHaltContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 148
                self.match(CommentMacroParser.T__16)
                self.state = 149
                self.target()
                self.state = 151
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 150
                    self.device()


                pass

            elif la_ == 18:
                localctx = CommentMacroParser.BatchAssertContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 153
                self.match(CommentMacroParser.T__17)
                self.state = 154
                self.target()
                self.state = 156
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 155
                    self.device()


                pass

            elif la_ == 19:
                localctx = CommentMacroParser.BatchReleaseContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 158
                self.match(CommentMacroParser.T__18)
                self.state = 159
                self.target()
                self.state = 161
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 160
                    self.device()


                pass

            elif la_ == 20:
                localctx = CommentMacroParser.SceneGoContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 163
                self.match(CommentMacroParser.T__19)
                self.state = 164
                self.target()
                self.state = 166
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 165
                    self.device()


                pass

            elif la_ == 21:
                localctx = CommentMacroParser.SceneHaltContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 168
                self.match(CommentMacroParser.T__20)
                self.state = 169
                self.target()
                self.state = 171
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 170
                    self.device()


                pass

            elif la_ == 22:
                localctx = CommentMacroParser.SceneAssertContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 173
                self.match(CommentMacroParser.T__21)
                self.state = 174
                self.target()
                self.state = 176
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 175
                    self.device()


                pass

            elif la_ == 23:
                localctx = CommentMacroParser.SceneReleaseContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 178
                self.match(CommentMacroParser.T__22)
                self.state = 179
                self.target()
                self.state = 181
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 180
                    self.device()


                pass

            elif la_ == 24:
                localctx = CommentMacroParser.PageChangeContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 183
                self.match(CommentMacroParser.T__23)
                self.state = 184
                self.number()
                self.state = 186
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 185
                    self.device()


                pass

            elif la_ == 25:
                localctx = CommentMacroParser.PageNextContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 188
                self.match(CommentMacroParser.T__23)
                self.state = 189
                self.match(CommentMacroParser.T__24)
                self.state = 191
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 190
                    self.device()


                pass

            elif la_ == 26:
                localctx = CommentMacroParser.PagePrevContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 193
                self.match(CommentMacroParser.T__23)
                self.state = 194
                self.match(CommentMacroParser.T__25)
                self.state = 196
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 195
                    self.device()


                pass

            elif la_ == 27:
                localctx = CommentMacroParser.RecallViewContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 198
                self.match(CommentMacroParser.T__26)
                self.state = 199
                self.number()
                self.state = 201
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 200
                    self.device()


                pass

            elif la_ == 28:
                localctx = CommentMacroParser.NodeResetContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 203
                self.match(CommentMacroParser.T__27)
                self.state = 204
                self.device()
                pass

            elif la_ == 29:
                localctx = CommentMacroParser.MacroGoContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 205
                self.match(CommentMacroParser.T__28)
                self.state = 206
                self.target()
                self.state = 208
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 207
                    self.device()


                pass

            elif la_ == 30:
                localctx = CommentMacroParser.MacroHaltContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 210
                self.match(CommentMacroParser.T__29)
                self.state = 211
                self.target()
                self.state = 213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 212
                    self.device()


                pass

            elif la_ == 31:
                localctx = CommentMacroParser.MacroStopContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 215
                self.match(CommentMacroParser.T__30)
                self.state = 216
                self.target()
                self.state = 218
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 217
                    self.device()


                pass

            elif la_ == 32:
                localctx = CommentMacroParser.SelectIntensityContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 220
                self.match(CommentMacroParser.T__31)
                self.state = 221
                self.number()
                self.state = 223
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 222
                    self.device()


                pass

            elif la_ == 33:
                localctx = CommentMacroParser.SelectPositionContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 225
                self.match(CommentMacroParser.T__32)
                self.state = 226
                self.number()
                self.state = 228
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 227
                    self.device()


                pass

            elif la_ == 34:
                localctx = CommentMacroParser.SelectColourContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 230
                self.match(CommentMacroParser.T__33)
                self.state = 231
                self.number()
                self.state = 233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 232
                    self.device()


                pass

            elif la_ == 35:
                localctx = CommentMacroParser.SelectBeamContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 235
                self.match(CommentMacroParser.T__34)
                self.state = 236
                self.number()
                self.state = 238
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
                    self.state = 237
                    self.device()


                pass

            elif la_ == 36:
                localctx = CommentMacroParser.WaitContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 240
                self.match(CommentMacroParser.T__35)
                self.state = 241
                self.number()
                pass

            elif la_ == 37:
                localctx = CommentMacroParser.PassContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 242
                self.match(CommentMacroParser.T__36)
                pass


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


    class TimeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TIME(self):
            return self.getToken(CommentMacroParser.TIME, 0)

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


        def getRuleIndex(self):
            return CommentMacroParser.RULE_time

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

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




    def time(self):

        localctx = CommentMacroParser.TimeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_time)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            self.match(CommentMacroParser.TIME)
            self.state = 246
            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 DeviceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nodeType(self):
            return self.getTypedRuleContext(CommentMacroParser.NodeTypeContext,0)


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


        def getRuleIndex(self):
            return CommentMacroParser.RULE_device

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

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




    def device(self):

        localctx = CommentMacroParser.DeviceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_device)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.nodeType()
            self.state = 249
            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 NodeTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHOLEHOG(self):
            return self.getToken(CommentMacroParser.WHOLEHOG, 0)

        def DP8K(self):
            return self.getToken(CommentMacroParser.DP8K, 0)

        def IOP(self):
            return self.getToken(CommentMacroParser.IOP, 0)

        def getRuleIndex(self):
            return CommentMacroParser.RULE_nodeType

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

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




    def nodeType(self):

        localctx = CommentMacroParser.NodeTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_nodeType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 251
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TargetContext(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(CommentMacroParser.NumberContext,0)


        def span(self):
            return self.getTypedRuleContext(CommentMacroParser.SpanContext,0)


        def target(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CommentMacroParser.TargetContext)
            else:
                return self.getTypedRuleContext(CommentMacroParser.TargetContext,i)


        def getRuleIndex(self):
            return CommentMacroParser.RULE_target

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

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




    def target(self):

        localctx = CommentMacroParser.TargetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_target)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 253
                self.number()
                pass

            elif la_ == 2:
                self.state = 254
                self.span()
                pass


            self.state = 261
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,48,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 257
                    self.match(CommentMacroParser.T__37)
                    self.state = 258
                    self.target() 
                self.state = 263
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,48,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 SpanContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def THRU(self):
            return self.getToken(CommentMacroParser.THRU, 0)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CommentMacroParser.NumberContext)
            else:
                return self.getTypedRuleContext(CommentMacroParser.NumberContext,i)


        def getRuleIndex(self):
            return CommentMacroParser.RULE_span

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

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




    def span(self):

        localctx = CommentMacroParser.SpanContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_span)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 264
            localctx.n1 = self.number()
            self.state = 265
            self.match(CommentMacroParser.THRU)
            self.state = 266
            localctx.n2 = 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 NumberContext(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.getToken(CommentMacroParser.NUMBER, 0)

        def getRuleIndex(self):
            return CommentMacroParser.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 = CommentMacroParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self.match(CommentMacroParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx