# Generated from PW_explorer/Input_Parsers/Meta_Data_Parser/Antlr_Files/PWE_ASP_Meta_Data.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\17")
        buf.write("\u0085\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\3\2\7\2\36\n\2\f\2\16\2!\13\2\3\3\6\3$\n\3\r\3\16")
        buf.write("\3%\3\3\3\3\3\4\3\4\3\4\5\4-\n\4\3\5\3\5\3\5\3\5\6\5\63")
        buf.write("\n\5\r\5\16\5\64\3\5\3\5\5\59\n\5\3\6\3\6\3\6\3\6\6\6")
        buf.write("?\n\6\r\6\16\6@\3\6\3\6\5\6E\n\6\3\7\3\7\3\7\3\7\5\7K")
        buf.write("\n\7\3\b\3\b\7\bO\n\b\f\b\16\bR\13\b\3\b\5\bU\n\b\3\t")
        buf.write("\3\t\3\t\3\t\6\t[\n\t\r\t\16\t\\\3\t\3\t\7\ta\n\t\f\t")
        buf.write("\16\td\13\t\3\t\5\tg\n\t\3\n\3\n\3\n\3\n\6\nm\n\n\r\n")
        buf.write("\16\nn\3\n\3\n\7\ns\n\n\f\n\16\nv\13\n\3\n\5\ny\n\n\3")
        buf.write("\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\16\3\16\3\16\2\2")
        buf.write("\17\2\4\6\b\n\f\16\20\22\24\26\30\32\2\2\2\u0089\2\37")
        buf.write("\3\2\2\2\4#\3\2\2\2\6,\3\2\2\2\b.\3\2\2\2\n:\3\2\2\2\f")
        buf.write("F\3\2\2\2\16L\3\2\2\2\20V\3\2\2\2\22h\3\2\2\2\24z\3\2")
        buf.write("\2\2\26|\3\2\2\2\30~\3\2\2\2\32\u0080\3\2\2\2\34\36\5")
        buf.write("\4\3\2\35\34\3\2\2\2\36!\3\2\2\2\37\35\3\2\2\2\37 \3\2")
        buf.write("\2\2 \3\3\2\2\2!\37\3\2\2\2\"$\7\3\2\2#\"\3\2\2\2$%\3")
        buf.write("\2\2\2%#\3\2\2\2%&\3\2\2\2&\'\3\2\2\2\'(\5\6\4\2(\5\3")
        buf.write("\2\2\2)-\5\b\5\2*-\5\n\6\2+-\5\f\7\2,)\3\2\2\2,*\3\2\2")
        buf.write("\2,+\3\2\2\2-\7\3\2\2\2./\7\4\2\2/\60\7\16\2\2\60\62\7")
        buf.write("\5\2\2\61\63\7\16\2\2\62\61\3\2\2\2\63\64\3\2\2\2\64\62")
        buf.write("\3\2\2\2\64\65\3\2\2\2\65\66\3\2\2\2\668\7\6\2\2\679\7")
        buf.write("\7\2\28\67\3\2\2\289\3\2\2\29\t\3\2\2\2:;\7\b\2\2;<\7")
        buf.write("\16\2\2<>\7\5\2\2=?\7\16\2\2>=\3\2\2\2?@\3\2\2\2@>\3\2")
        buf.write("\2\2@A\3\2\2\2AB\3\2\2\2BD\7\6\2\2CE\7\7\2\2DC\3\2\2\2")
        buf.write("DE\3\2\2\2E\13\3\2\2\2FJ\7\t\2\2GK\5\16\b\2HK\5\20\t\2")
        buf.write("IK\5\22\n\2JG\3\2\2\2JH\3\2\2\2JI\3\2\2\2K\r\3\2\2\2L")
        buf.write("P\7\n\2\2MO\5\24\13\2NM\3\2\2\2OR\3\2\2\2PN\3\2\2\2PQ")
        buf.write("\3\2\2\2QT\3\2\2\2RP\3\2\2\2SU\7\7\2\2TS\3\2\2\2TU\3\2")
        buf.write("\2\2U\17\3\2\2\2VW\7\13\2\2WX\7\16\2\2XZ\7\5\2\2Y[\7\16")
        buf.write("\2\2ZY\3\2\2\2[\\\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]^\3\2")
        buf.write("\2\2^b\7\6\2\2_a\5\26\f\2`_\3\2\2\2ad\3\2\2\2b`\3\2\2")
        buf.write("\2bc\3\2\2\2cf\3\2\2\2db\3\2\2\2eg\7\7\2\2fe\3\2\2\2f")
        buf.write("g\3\2\2\2g\21\3\2\2\2hi\7\f\2\2ij\7\16\2\2jl\7\5\2\2k")
        buf.write("m\7\16\2\2lk\3\2\2\2mn\3\2\2\2nl\3\2\2\2no\3\2\2\2op\3")
        buf.write("\2\2\2pt\7\6\2\2qs\5\30\r\2rq\3\2\2\2sv\3\2\2\2tr\3\2")
        buf.write("\2\2tu\3\2\2\2ux\3\2\2\2vt\3\2\2\2wy\7\7\2\2xw\3\2\2\2")
        buf.write("xy\3\2\2\2y\23\3\2\2\2z{\5\32\16\2{\25\3\2\2\2|}\5\32")
        buf.write("\16\2}\27\3\2\2\2~\177\5\32\16\2\177\31\3\2\2\2\u0080")
        buf.write("\u0081\7\16\2\2\u0081\u0082\7\r\2\2\u0082\u0083\7\16\2")
        buf.write("\2\u0083\33\3\2\2\2\22\37%,\648@DJPT\\bfntx")
        return buf.getvalue()


class PWE_ASP_Meta_DataParser ( Parser ):

    grammarFileName = "PWE_ASP_Meta_Data.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'%'", "'schema'", "'('", "')'", "'.'", 
                     "'temporal'", "'graphviz'", "'graph'", "'node'", "'edge'", 
                     "'='" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "TEXT", "WHITESPACE" ]

    RULE_aspFile = 0
    RULE_comment = 1
    RULE_meta_data_comment = 2
    RULE_attr_def = 3
    RULE_temporal_dec = 4
    RULE_graphviz_styling = 5
    RULE_graphviz_graph_dec = 6
    RULE_graphviz_node_dec = 7
    RULE_graphviz_edge_dec = 8
    RULE_graphviz_graph_style_option = 9
    RULE_graphviz_node_style_option = 10
    RULE_graphviz_edge_style_option = 11
    RULE_graphviz_style_option = 12

    ruleNames =  [ "aspFile", "comment", "meta_data_comment", "attr_def", 
                   "temporal_dec", "graphviz_styling", "graphviz_graph_dec", 
                   "graphviz_node_dec", "graphviz_edge_dec", "graphviz_graph_style_option", 
                   "graphviz_node_style_option", "graphviz_edge_style_option", 
                   "graphviz_style_option" ]

    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
    TEXT=12
    WHITESPACE=13

    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 AspFileContext(ParserRuleContext):

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

        def comment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PWE_ASP_Meta_DataParser.CommentContext)
            else:
                return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.CommentContext,i)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_aspFile

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

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




    def aspFile(self):

        localctx = PWE_ASP_Meta_DataParser.AspFileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_aspFile)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 29
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PWE_ASP_Meta_DataParser.T__0:
                self.state = 26
                self.comment()
                self.state = 31
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class CommentContext(ParserRuleContext):

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

        def meta_data_comment(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Meta_data_commentContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_comment

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

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




    def comment(self):

        localctx = PWE_ASP_Meta_DataParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_comment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 33 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 32
                self.match(PWE_ASP_Meta_DataParser.T__0)
                self.state = 35 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==PWE_ASP_Meta_DataParser.T__0):
                    break

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

    class Meta_data_commentContext(ParserRuleContext):

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

        def attr_def(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Attr_defContext,0)


        def temporal_dec(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Temporal_decContext,0)


        def graphviz_styling(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_stylingContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_meta_data_comment

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

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




    def meta_data_comment(self):

        localctx = PWE_ASP_Meta_DataParser.Meta_data_commentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_meta_data_comment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 42
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PWE_ASP_Meta_DataParser.T__1]:
                self.state = 39
                self.attr_def()
                pass
            elif token in [PWE_ASP_Meta_DataParser.T__5]:
                self.state = 40
                self.temporal_dec()
                pass
            elif token in [PWE_ASP_Meta_DataParser.T__6]:
                self.state = 41
                self.graphviz_styling()
                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 Attr_defContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_attr_def

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

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




    def attr_def(self):

        localctx = PWE_ASP_Meta_DataParser.Attr_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_attr_def)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 44
            self.match(PWE_ASP_Meta_DataParser.T__1)
            self.state = 45
            self.match(PWE_ASP_Meta_DataParser.TEXT)
            self.state = 46
            self.match(PWE_ASP_Meta_DataParser.T__2)
            self.state = 48 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 47
                self.match(PWE_ASP_Meta_DataParser.TEXT)
                self.state = 50 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==PWE_ASP_Meta_DataParser.TEXT):
                    break

            self.state = 52
            self.match(PWE_ASP_Meta_DataParser.T__3)
            self.state = 54
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PWE_ASP_Meta_DataParser.T__4:
                self.state = 53
                self.match(PWE_ASP_Meta_DataParser.T__4)


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

    class Temporal_decContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_temporal_dec

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

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




    def temporal_dec(self):

        localctx = PWE_ASP_Meta_DataParser.Temporal_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_temporal_dec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 56
            self.match(PWE_ASP_Meta_DataParser.T__5)
            self.state = 57
            self.match(PWE_ASP_Meta_DataParser.TEXT)
            self.state = 58
            self.match(PWE_ASP_Meta_DataParser.T__2)
            self.state = 60 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 59
                self.match(PWE_ASP_Meta_DataParser.TEXT)
                self.state = 62 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==PWE_ASP_Meta_DataParser.TEXT):
                    break

            self.state = 64
            self.match(PWE_ASP_Meta_DataParser.T__3)
            self.state = 66
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PWE_ASP_Meta_DataParser.T__4:
                self.state = 65
                self.match(PWE_ASP_Meta_DataParser.T__4)


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

    class Graphviz_stylingContext(ParserRuleContext):

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

        def graphviz_graph_dec(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_graph_decContext,0)


        def graphviz_node_dec(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_node_decContext,0)


        def graphviz_edge_dec(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_edge_decContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_styling

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

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




    def graphviz_styling(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_stylingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_graphviz_styling)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 68
            self.match(PWE_ASP_Meta_DataParser.T__6)
            self.state = 72
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PWE_ASP_Meta_DataParser.T__7]:
                self.state = 69
                self.graphviz_graph_dec()
                pass
            elif token in [PWE_ASP_Meta_DataParser.T__8]:
                self.state = 70
                self.graphviz_node_dec()
                pass
            elif token in [PWE_ASP_Meta_DataParser.T__9]:
                self.state = 71
                self.graphviz_edge_dec()
                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 Graphviz_graph_decContext(ParserRuleContext):

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

        def graphviz_graph_style_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PWE_ASP_Meta_DataParser.Graphviz_graph_style_optionContext)
            else:
                return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_graph_style_optionContext,i)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_graph_dec

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

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




    def graphviz_graph_dec(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_graph_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_graphviz_graph_dec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 74
            self.match(PWE_ASP_Meta_DataParser.T__7)
            self.state = 78
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PWE_ASP_Meta_DataParser.TEXT:
                self.state = 75
                self.graphviz_graph_style_option()
                self.state = 80
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 82
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PWE_ASP_Meta_DataParser.T__4:
                self.state = 81
                self.match(PWE_ASP_Meta_DataParser.T__4)


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

    class Graphviz_node_decContext(ParserRuleContext):

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

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

        def graphviz_node_style_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PWE_ASP_Meta_DataParser.Graphviz_node_style_optionContext)
            else:
                return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_node_style_optionContext,i)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_node_dec

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

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




    def graphviz_node_dec(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_node_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_graphviz_node_dec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 84
            self.match(PWE_ASP_Meta_DataParser.T__8)
            self.state = 85
            self.match(PWE_ASP_Meta_DataParser.TEXT)
            self.state = 86
            self.match(PWE_ASP_Meta_DataParser.T__2)
            self.state = 88 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 87
                self.match(PWE_ASP_Meta_DataParser.TEXT)
                self.state = 90 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==PWE_ASP_Meta_DataParser.TEXT):
                    break

            self.state = 92
            self.match(PWE_ASP_Meta_DataParser.T__3)
            self.state = 96
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PWE_ASP_Meta_DataParser.TEXT:
                self.state = 93
                self.graphviz_node_style_option()
                self.state = 98
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 100
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PWE_ASP_Meta_DataParser.T__4:
                self.state = 99
                self.match(PWE_ASP_Meta_DataParser.T__4)


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

    class Graphviz_edge_decContext(ParserRuleContext):

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

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

        def graphviz_edge_style_option(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PWE_ASP_Meta_DataParser.Graphviz_edge_style_optionContext)
            else:
                return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_edge_style_optionContext,i)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_edge_dec

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

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




    def graphviz_edge_dec(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_edge_decContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_graphviz_edge_dec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 102
            self.match(PWE_ASP_Meta_DataParser.T__9)
            self.state = 103
            self.match(PWE_ASP_Meta_DataParser.TEXT)
            self.state = 104
            self.match(PWE_ASP_Meta_DataParser.T__2)
            self.state = 106 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 105
                self.match(PWE_ASP_Meta_DataParser.TEXT)
                self.state = 108 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==PWE_ASP_Meta_DataParser.TEXT):
                    break

            self.state = 110
            self.match(PWE_ASP_Meta_DataParser.T__3)
            self.state = 114
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PWE_ASP_Meta_DataParser.TEXT:
                self.state = 111
                self.graphviz_edge_style_option()
                self.state = 116
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 118
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PWE_ASP_Meta_DataParser.T__4:
                self.state = 117
                self.match(PWE_ASP_Meta_DataParser.T__4)


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

    class Graphviz_graph_style_optionContext(ParserRuleContext):

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

        def graphviz_style_option(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_style_optionContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_graph_style_option

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

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




    def graphviz_graph_style_option(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_graph_style_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_graphviz_graph_style_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 120
            self.graphviz_style_option()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Graphviz_node_style_optionContext(ParserRuleContext):

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

        def graphviz_style_option(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_style_optionContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_node_style_option

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

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




    def graphviz_node_style_option(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_node_style_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_graphviz_node_style_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 122
            self.graphviz_style_option()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Graphviz_edge_style_optionContext(ParserRuleContext):

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

        def graphviz_style_option(self):
            return self.getTypedRuleContext(PWE_ASP_Meta_DataParser.Graphviz_style_optionContext,0)


        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_edge_style_option

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

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




    def graphviz_edge_style_option(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_edge_style_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_graphviz_edge_style_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 124
            self.graphviz_style_option()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Graphviz_style_optionContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return PWE_ASP_Meta_DataParser.RULE_graphviz_style_option

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

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




    def graphviz_style_option(self):

        localctx = PWE_ASP_Meta_DataParser.Graphviz_style_optionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_graphviz_style_option)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 126
            self.match(PWE_ASP_Meta_DataParser.TEXT)
            self.state = 127
            self.match(PWE_ASP_Meta_DataParser.T__10)
            self.state = 128
            self.match(PWE_ASP_Meta_DataParser.TEXT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





