# Generated from CommentMacro.g4 by ANTLR 4.7.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys

def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3-")
        buf.write("\u00ed\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\3\2\6\2\30\n\2\r\2")
        buf.write("\16\2\31\3\2\3\2\3\3\3\3\3\3\7\3!\n\3\f\3\16\3$\13\3\3")
        buf.write("\3\5\3\'\n\3\3\3\5\3*\n\3\3\4\3\4\3\4\5\4/\n\4\3\4\3\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\3\4\3\4\5\4E\n\4\3\4\3\4\5\4I\n\4\3\4")
        buf.write("\3\4\5\4M\n\4\3\4\3\4\3\4\3\4\3\4\5\4T\n\4\3\4\5\4W\n")
        buf.write("\4\3\4\3\4\3\4\5\4\\\n\4\3\4\5\4_\n\4\3\4\3\4\3\4\5\4")
        buf.write("d\n\4\3\4\3\4\3\4\5\4i\n\4\3\4\3\4\3\4\3\4\3\4\5\4p\n")
        buf.write("\4\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")
        buf.write("\4\5\4\177\n\4\3\4\3\4\3\4\5\4\u0084\n\4\3\4\3\4\3\4\5")
        buf.write("\4\u0089\n\4\3\4\3\4\3\4\5\4\u008e\n\4\3\4\3\4\3\4\5\4")
        buf.write("\u0093\n\4\3\4\3\4\3\4\5\4\u0098\n\4\3\4\3\4\3\4\5\4\u009d")
        buf.write("\n\4\3\4\3\4\3\4\5\4\u00a2\n\4\3\4\3\4\3\4\5\4\u00a7\n")
        buf.write("\4\3\4\3\4\3\4\5\4\u00ac\n\4\3\4\3\4\3\4\5\4\u00b1\n\4")
        buf.write("\3\4\3\4\3\4\5\4\u00b6\n\4\3\4\3\4\3\4\5\4\u00bb\n\4\3")
        buf.write("\4\3\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\5\4\u00ce\n\4\3\5\3\5\5")
        buf.write("\5\u00d2\n\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\t\3\t\5")
        buf.write("\t\u00de\n\t\3\t\3\t\7\t\u00e2\n\t\f\t\16\t\u00e5\13\t")
        buf.write("\3\n\3\n\3\n\3\n\3\13\3\13\3\13\2\2\f\2\4\6\b\n\f\16\20")
        buf.write("\22\24\2\3\3\2\')\2\u0127\2\27\3\2\2\2\4)\3\2\2\2\6\u00cd")
        buf.write("\3\2\2\2\b\u00d1\3\2\2\2\n\u00d3\3\2\2\2\f\u00d6\3\2\2")
        buf.write("\2\16\u00d9\3\2\2\2\20\u00dd\3\2\2\2\22\u00e6\3\2\2\2")
        buf.write("\24\u00ea\3\2\2\2\26\30\5\4\3\2\27\26\3\2\2\2\30\31\3")
        buf.write("\2\2\2\31\27\3\2\2\2\31\32\3\2\2\2\32\33\3\2\2\2\33\34")
        buf.write("\7\2\2\3\34\3\3\2\2\2\35\"\5\6\4\2\36\37\7\3\2\2\37!\5")
        buf.write("\6\4\2 \36\3\2\2\2!$\3\2\2\2\" \3\2\2\2\"#\3\2\2\2#&\3")
        buf.write("\2\2\2$\"\3\2\2\2%\'\7*\2\2&%\3\2\2\2&\'\3\2\2\2\'*\3")
        buf.write("\2\2\2(*\7*\2\2)\35\3\2\2\2)(\3\2\2\2*\5\3\2\2\2+,\7\4")
        buf.write("\2\2,.\5\b\5\2-/\5\f\7\2.-\3\2\2\2./\3\2\2\2/\u00ce\3")
        buf.write("\2\2\2\60\61\7\4\2\2\61\62\5\b\5\2\62\63\7!\2\2\63\65")
        buf.write("\5\24\13\2\64\66\5\f\7\2\65\64\3\2\2\2\65\66\3\2\2\2\66")
        buf.write("\u00ce\3\2\2\2\678\7\5\2\28:\5\b\5\29;\5\f\7\2:9\3\2\2")
        buf.write("\2:;\3\2\2\2;\u00ce\3\2\2\2<=\7\6\2\2=?\5\b\5\2>@\5\f")
        buf.write("\7\2?>\3\2\2\2?@\3\2\2\2@\u00ce\3\2\2\2AB\7\7\2\2BD\5")
        buf.write("\b\5\2CE\5\f\7\2DC\3\2\2\2DE\3\2\2\2E\u00ce\3\2\2\2FH")
        buf.write("\7\b\2\2GI\5\f\7\2HG\3\2\2\2HI\3\2\2\2I\u00ce\3\2\2\2")
        buf.write("JL\7\t\2\2KM\5\f\7\2LK\3\2\2\2LM\3\2\2\2M\u00ce\3\2\2")
        buf.write("\2NO\7\n\2\2OP\5\b\5\2PQ\7!\2\2QS\5\24\13\2RT\5\n\6\2")
        buf.write("SR\3\2\2\2ST\3\2\2\2TV\3\2\2\2UW\5\f\7\2VU\3\2\2\2VW\3")
        buf.write("\2\2\2W\u00ce\3\2\2\2XY\7\13\2\2Y[\5\24\13\2Z\\\5\n\6")
        buf.write("\2[Z\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2]_\5\f\7\2^]\3\2\2\2")
        buf.write("^_\3\2\2\2_\u00ce\3\2\2\2`a\7\f\2\2ac\5\24\13\2bd\5\f")
        buf.write("\7\2cb\3\2\2\2cd\3\2\2\2d\u00ce\3\2\2\2ef\7\r\2\2fh\5")
        buf.write("\20\t\2gi\5\f\7\2hg\3\2\2\2hi\3\2\2\2i\u00ce\3\2\2\2j")
        buf.write("k\7\r\2\2kl\5\20\t\2lm\7!\2\2mo\5\24\13\2np\5\f\7\2on")
        buf.write("\3\2\2\2op\3\2\2\2p\u00ce\3\2\2\2qr\7\16\2\2rt\5\20\t")
        buf.write("\2su\5\f\7\2ts\3\2\2\2tu\3\2\2\2u\u00ce\3\2\2\2vw\7\17")
        buf.write("\2\2wy\5\20\t\2xz\5\f\7\2yx\3\2\2\2yz\3\2\2\2z\u00ce\3")
        buf.write("\2\2\2{|\7\20\2\2|~\5\20\t\2}\177\5\f\7\2~}\3\2\2\2~\177")
        buf.write("\3\2\2\2\177\u00ce\3\2\2\2\u0080\u0081\7\21\2\2\u0081")
        buf.write("\u0083\5\20\t\2\u0082\u0084\5\f\7\2\u0083\u0082\3\2\2")
        buf.write("\2\u0083\u0084\3\2\2\2\u0084\u00ce\3\2\2\2\u0085\u0086")
        buf.write("\7\22\2\2\u0086\u0088\5\20\t\2\u0087\u0089\5\f\7\2\u0088")
        buf.write("\u0087\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u00ce\3\2\2\2")
        buf.write("\u008a\u008b\7\23\2\2\u008b\u008d\5\20\t\2\u008c\u008e")
        buf.write("\5\f\7\2\u008d\u008c\3\2\2\2\u008d\u008e\3\2\2\2\u008e")
        buf.write("\u00ce\3\2\2\2\u008f\u0090\7\24\2\2\u0090\u0092\5\20\t")
        buf.write("\2\u0091\u0093\5\f\7\2\u0092\u0091\3\2\2\2\u0092\u0093")
        buf.write("\3\2\2\2\u0093\u00ce\3\2\2\2\u0094\u0095\7\25\2\2\u0095")
        buf.write("\u0097\5\20\t\2\u0096\u0098\5\f\7\2\u0097\u0096\3\2\2")
        buf.write("\2\u0097\u0098\3\2\2\2\u0098\u00ce\3\2\2\2\u0099\u009a")
        buf.write("\7\26\2\2\u009a\u009c\5\20\t\2\u009b\u009d\5\f\7\2\u009c")
        buf.write("\u009b\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u00ce\3\2\2\2")
        buf.write("\u009e\u009f\7\27\2\2\u009f\u00a1\5\20\t\2\u00a0\u00a2")
        buf.write("\5\f\7\2\u00a1\u00a0\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2")
        buf.write("\u00ce\3\2\2\2\u00a3\u00a4\7\30\2\2\u00a4\u00a6\5\20\t")
        buf.write("\2\u00a5\u00a7\5\f\7\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7")
        buf.write("\3\2\2\2\u00a7\u00ce\3\2\2\2\u00a8\u00a9\7\31\2\2\u00a9")
        buf.write("\u00ab\5\24\13\2\u00aa\u00ac\5\f\7\2\u00ab\u00aa\3\2\2")
        buf.write("\2\u00ab\u00ac\3\2\2\2\u00ac\u00ce\3\2\2\2\u00ad\u00ae")
        buf.write("\7\31\2\2\u00ae\u00b0\7#\2\2\u00af\u00b1\5\f\7\2\u00b0")
        buf.write("\u00af\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00ce\3\2\2\2")
        buf.write("\u00b2\u00b3\7\31\2\2\u00b3\u00b5\7$\2\2\u00b4\u00b6\5")
        buf.write("\f\7\2\u00b5\u00b4\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00ce")
        buf.write("\3\2\2\2\u00b7\u00b8\7\32\2\2\u00b8\u00ba\5\24\13\2\u00b9")
        buf.write("\u00bb\5\f\7\2\u00ba\u00b9\3\2\2\2\u00ba\u00bb\3\2\2\2")
        buf.write("\u00bb\u00ce\3\2\2\2\u00bc\u00bd\7\33\2\2\u00bd\u00ce")
        buf.write("\5\f\7\2\u00be\u00bf\7\34\2\2\u00bf\u00c1\5\24\13\2\u00c0")
        buf.write("\u00c2\5\f\7\2\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2")
        buf.write("\u00c2\u00ce\3\2\2\2\u00c3\u00c4\7\35\2\2\u00c4\u00c6")
        buf.write("\5\24\13\2\u00c5\u00c7\5\f\7\2\u00c6\u00c5\3\2\2\2\u00c6")
        buf.write("\u00c7\3\2\2\2\u00c7\u00ce\3\2\2\2\u00c8\u00c9\7\36\2")
        buf.write("\2\u00c9\u00cb\5\24\13\2\u00ca\u00cc\5\f\7\2\u00cb\u00ca")
        buf.write("\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00ce\3\2\2\2\u00cd")
        buf.write("+\3\2\2\2\u00cd\60\3\2\2\2\u00cd\67\3\2\2\2\u00cd<\3\2")
        buf.write("\2\2\u00cdA\3\2\2\2\u00cdF\3\2\2\2\u00cdJ\3\2\2\2\u00cd")
        buf.write("N\3\2\2\2\u00cdX\3\2\2\2\u00cd`\3\2\2\2\u00cde\3\2\2\2")
        buf.write("\u00cdj\3\2\2\2\u00cdq\3\2\2\2\u00cdv\3\2\2\2\u00cd{\3")
        buf.write("\2\2\2\u00cd\u0080\3\2\2\2\u00cd\u0085\3\2\2\2\u00cd\u008a")
        buf.write("\3\2\2\2\u00cd\u008f\3\2\2\2\u00cd\u0094\3\2\2\2\u00cd")
        buf.write("\u0099\3\2\2\2\u00cd\u009e\3\2\2\2\u00cd\u00a3\3\2\2\2")
        buf.write("\u00cd\u00a8\3\2\2\2\u00cd\u00ad\3\2\2\2\u00cd\u00b2\3")
        buf.write("\2\2\2\u00cd\u00b7\3\2\2\2\u00cd\u00bc\3\2\2\2\u00cd\u00be")
        buf.write("\3\2\2\2\u00cd\u00c3\3\2\2\2\u00cd\u00c8\3\2\2\2\u00ce")
        buf.write("\7\3\2\2\2\u00cf\u00d2\5\20\t\2\u00d0\u00d2\7%\2\2\u00d1")
        buf.write("\u00cf\3\2\2\2\u00d1\u00d0\3\2\2\2\u00d2\t\3\2\2\2\u00d3")
        buf.write("\u00d4\7&\2\2\u00d4\u00d5\5\24\13\2\u00d5\13\3\2\2\2\u00d6")
        buf.write("\u00d7\5\16\b\2\u00d7\u00d8\5\24\13\2\u00d8\r\3\2\2\2")
        buf.write("\u00d9\u00da\t\2\2\2\u00da\17\3\2\2\2\u00db\u00de\5\24")
        buf.write("\13\2\u00dc\u00de\5\22\n\2\u00dd\u00db\3\2\2\2\u00dd\u00dc")
        buf.write("\3\2\2\2\u00de\u00e3\3\2\2\2\u00df\u00e0\7\37\2\2\u00e0")
        buf.write("\u00e2\5\20\t\2\u00e1\u00df\3\2\2\2\u00e2\u00e5\3\2\2")
        buf.write("\2\u00e3\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\21\3")
        buf.write("\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00e7\5\24\13\2\u00e7")
        buf.write("\u00e8\7\"\2\2\u00e8\u00e9\5\24\13\2\u00e9\23\3\2\2\2")
        buf.write("\u00ea\u00eb\7 \2\2\u00eb\25\3\2\2\2*\31\"&).\65:?DHL")
        buf.write("SV[^choty~\u0083\u0088\u008d\u0092\u0097\u009c\u00a1\u00a6")
        buf.write("\u00ab\u00b0\u00b5\u00ba\u00c1\u00c6\u00cb\u00cd\u00d1")
        buf.write("\u00dd\u00e3")
        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'", "','", "<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>", "NUMBER", "SLASH", "THRU", 
                      "NEXT", "PREV", "CURRENT", "TIME", "WHOLEHOG", "DP8K", 
                      "IOP", "NEWLINE", "WS", "COMMENT", "LINE_COMMENT" ]

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

    ruleNames =  [ "prog", "statement", "macro", "master", "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
    NUMBER=30
    SLASH=31
    THRU=32
    NEXT=33
    PREV=34
    CURRENT=35
    TIME=36
    WHOLEHOG=37
    DP8K=38
    IOP=39
    NEWLINE=40
    WS=41
    COMMENT=42
    LINE_COMMENT=43

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



    class ProgContext(ParserRuleContext):

        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 True:
                self.state = 20
                self.statement()
                self.state = 23 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.T__1) | (1 << CommentMacroParser.T__2) | (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__24) | (1 << CommentMacroParser.T__25) | (1 << CommentMacroParser.T__26) | (1 << CommentMacroParser.T__27) | (1 << CommentMacroParser.NEWLINE))) != 0)):
                    break

            self.state = 25
            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):

        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 = 39
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CommentMacroParser.T__1, CommentMacroParser.T__2, 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__24, CommentMacroParser.T__25, CommentMacroParser.T__26, CommentMacroParser.T__27]:
                self.enterOuterAlt(localctx, 1)
                self.state = 27
                self.macro()
                self.state = 32
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CommentMacroParser.T__0:
                    self.state = 28
                    self.match(CommentMacroParser.T__0)
                    self.state = 29
                    self.macro()
                    self.state = 34
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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


                pass
            elif token in [CommentMacroParser.NEWLINE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 38
                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):

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

        def master(self):
            return self.getTypedRuleContext(CommentMacroParser.MasterContext,0)


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


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

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


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


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


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

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

        def getRuleIndex(self):
            return CommentMacroParser.RULE_macro

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

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMacro" ):
                listener.exitMacro(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 = 203
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 41
                self.match(CommentMacroParser.T__1)
                self.state = 42
                self.master()
                self.state = 44
                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 = 43
                    self.device()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 46
                self.match(CommentMacroParser.T__1)
                self.state = 47
                self.master()
                self.state = 48
                self.match(CommentMacroParser.SLASH)
                self.state = 49
                self.number()
                self.state = 51
                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 = 50
                    self.device()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 53
                self.match(CommentMacroParser.T__2)
                self.state = 54
                self.master()
                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_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 58
                self.match(CommentMacroParser.T__3)
                self.state = 59
                self.master()
                self.state = 61
                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 = 60
                    self.device()


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 63
                self.match(CommentMacroParser.T__4)
                self.state = 64
                self.master()
                self.state = 66
                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 = 65
                    self.device()


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 68
                self.match(CommentMacroParser.T__5)
                self.state = 70
                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 = 69
                    self.device()


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 72
                self.match(CommentMacroParser.T__6)
                self.state = 74
                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 = 73
                    self.device()


                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 76
                self.match(CommentMacroParser.T__7)
                self.state = 77
                self.master()
                self.state = 78
                self.match(CommentMacroParser.SLASH)
                self.state = 79
                self.number()
                self.state = 81
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CommentMacroParser.TIME:
                    self.state = 80
                    self.time()


                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_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 86
                self.match(CommentMacroParser.T__8)
                self.state = 87
                self.number()
                self.state = 89
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CommentMacroParser.TIME:
                    self.state = 88
                    self.time()


                self.state = 92
                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 = 91
                    self.device()


                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 94
                self.match(CommentMacroParser.T__9)
                self.state = 95
                self.number()
                self.state = 97
                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 = 96
                    self.device()


                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 99
                self.match(CommentMacroParser.T__10)
                self.state = 100
                self.target()
                self.state = 102
                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 = 101
                    self.device()


                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 104
                self.match(CommentMacroParser.T__10)
                self.state = 105
                self.target()
                self.state = 106
                self.match(CommentMacroParser.SLASH)
                self.state = 107
                self.number()
                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_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 111
                self.match(CommentMacroParser.T__11)
                self.state = 112
                self.target()
                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_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 116
                self.match(CommentMacroParser.T__12)
                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_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 121
                self.match(CommentMacroParser.T__13)
                self.state = 122
                self.target()
                self.state = 124
                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 = 123
                    self.device()


                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 126
                self.match(CommentMacroParser.T__14)
                self.state = 127
                self.target()
                self.state = 129
                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 = 128
                    self.device()


                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 131
                self.match(CommentMacroParser.T__15)
                self.state = 132
                self.target()
                self.state = 134
                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 = 133
                    self.device()


                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 136
                self.match(CommentMacroParser.T__16)
                self.state = 137
                self.target()
                self.state = 139
                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 = 138
                    self.device()


                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 141
                self.match(CommentMacroParser.T__17)
                self.state = 142
                self.target()
                self.state = 144
                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 = 143
                    self.device()


                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 146
                self.match(CommentMacroParser.T__18)
                self.state = 147
                self.target()
                self.state = 149
                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 = 148
                    self.device()


                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 151
                self.match(CommentMacroParser.T__19)
                self.state = 152
                self.target()
                self.state = 154
                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 = 153
                    self.device()


                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 156
                self.match(CommentMacroParser.T__20)
                self.state = 157
                self.target()
                self.state = 159
                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 = 158
                    self.device()


                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 161
                self.match(CommentMacroParser.T__21)
                self.state = 162
                self.target()
                self.state = 164
                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 = 163
                    self.device()


                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 166
                self.match(CommentMacroParser.T__22)
                self.state = 167
                self.number()
                self.state = 169
                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 = 168
                    self.device()


                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 171
                self.match(CommentMacroParser.T__22)
                self.state = 172
                self.match(CommentMacroParser.NEXT)
                self.state = 174
                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 = 173
                    self.device()


                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 176
                self.match(CommentMacroParser.T__22)
                self.state = 177
                self.match(CommentMacroParser.PREV)
                self.state = 179
                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 = 178
                    self.device()


                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 181
                self.match(CommentMacroParser.T__23)
                self.state = 182
                self.number()
                self.state = 184
                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 = 183
                    self.device()


                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 186
                self.match(CommentMacroParser.T__24)
                self.state = 187
                self.device()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 188
                self.match(CommentMacroParser.T__25)
                self.state = 189
                self.number()
                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_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 193
                self.match(CommentMacroParser.T__26)
                self.state = 194
                self.number()
                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_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 198
                self.match(CommentMacroParser.T__27)
                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


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

    class MasterContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CommentMacroParser.RULE_master

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

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




    def master(self):

        localctx = CommentMacroParser.MasterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_master)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 207
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CommentMacroParser.NUMBER]:
                self.state = 205
                self.target()
                pass
            elif token in [CommentMacroParser.CURRENT]:
                self.state = 206
                self.match(CommentMacroParser.CURRENT)
                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 TimeContext(ParserRuleContext):

        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, 8, self.RULE_time)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self.match(CommentMacroParser.TIME)
            self.state = 210
            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):

        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, 10, self.RULE_device)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 212
            self.nodeType()
            self.state = 213
            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):

        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, 12, self.RULE_nodeType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 215
            _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):

        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, 14, self.RULE_target)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.state = 217
                self.number()
                pass

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


            self.state = 225
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,39,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 221
                    self.match(CommentMacroParser.T__28)
                    self.state = 222
                    self.target() 
                self.state = 227
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,39,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):

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

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


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

        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, 16, self.RULE_span)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self.number()
            self.state = 229
            self.match(CommentMacroParser.THRU)
            self.state = 230
            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):

        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, 18, self.RULE_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            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