# flake8: noqa
# type: ignore
# Generated from Hocon.g4 by ANTLR 4.8
# encoding: utf-8
from ....._vendor.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\20")
        buf.write("\u00c7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\3\2")
        buf.write("\7\2\62\n\2\f\2\16\2\65\13\2\3\2\7\28\n\2\f\2\16\2;\13")
        buf.write("\2\3\2\7\2>\n\2\f\2\16\2A\13\2\5\2C\n\2\3\3\3\3\3\3\3")
        buf.write("\3\3\3\5\3J\n\3\3\4\3\4\3\4\5\4O\n\4\3\4\7\4R\n\4\f\4")
        buf.write("\16\4U\13\4\3\4\3\4\3\4\3\4\3\4\5\4\\\n\4\3\5\3\5\3\6")
        buf.write("\3\6\3\7\3\7\5\7d\n\7\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t")
        buf.write("\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\5")
        buf.write("\fz\n\f\3\r\3\r\3\r\7\r\177\n\r\f\r\16\r\u0082\13\r\3")
        buf.write("\16\3\16\3\17\3\17\3\20\3\20\3\20\5\20\u008b\n\20\3\20")
        buf.write("\7\20\u008e\n\20\f\20\16\20\u0091\13\20\3\20\3\20\3\20")
        buf.write("\3\20\3\20\5\20\u0098\n\20\3\21\3\21\3\21\3\21\3\21\5")
        buf.write("\21\u009f\n\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25")
        buf.write("\3\26\3\26\3\27\3\27\7\27\u00ad\n\27\f\27\16\27\u00b0")
        buf.write("\13\27\3\27\3\27\7\27\u00b4\n\27\f\27\16\27\u00b7\13\27")
        buf.write("\3\27\3\27\7\27\u00bb\n\27\f\27\16\27\u00be\13\27\5\27")
        buf.write("\u00c0\n\27\3\30\6\30\u00c3\n\30\r\30\16\30\u00c4\3\30")
        buf.write("\2\2\31\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*")
        buf.write(",.\2\3\4\2\t\t\r\r\2\u00cb\2B\3\2\2\2\4I\3\2\2\2\6[\3")
        buf.write("\2\2\2\b]\3\2\2\2\n_\3\2\2\2\fa\3\2\2\2\16g\3\2\2\2\20")
        buf.write("k\3\2\2\2\22o\3\2\2\2\24s\3\2\2\2\26y\3\2\2\2\30{\3\2")
        buf.write("\2\2\32\u0083\3\2\2\2\34\u0085\3\2\2\2\36\u0097\3\2\2")
        buf.write("\2 \u009e\3\2\2\2\"\u00a0\3\2\2\2$\u00a2\3\2\2\2&\u00a4")
        buf.write("\3\2\2\2(\u00a6\3\2\2\2*\u00a8\3\2\2\2,\u00bf\3\2\2\2")
        buf.write(".\u00c2\3\2\2\2\60\62\5\6\4\2\61\60\3\2\2\2\62\65\3\2")
        buf.write("\2\2\63\61\3\2\2\2\63\64\3\2\2\2\64C\3\2\2\2\65\63\3\2")
        buf.write("\2\2\668\5\36\20\2\67\66\3\2\2\28;\3\2\2\29\67\3\2\2\2")
        buf.write("9:\3\2\2\2:C\3\2\2\2;9\3\2\2\2<>\5\4\3\2=<\3\2\2\2>A\3")
        buf.write("\2\2\2?=\3\2\2\2?@\3\2\2\2@C\3\2\2\2A?\3\2\2\2B\63\3\2")
        buf.write("\2\2B9\3\2\2\2B?\3\2\2\2C\3\3\2\2\2DJ\5\f\7\2EJ\5\16\b")
        buf.write("\2FJ\5\20\t\2GJ\5\22\n\2HJ\5\24\13\2ID\3\2\2\2IE\3\2\2")
        buf.write("\2IF\3\2\2\2IG\3\2\2\2IH\3\2\2\2J\5\3\2\2\2KL\5\b\5\2")
        buf.write("LS\5\4\3\2MO\7\3\2\2NM\3\2\2\2NO\3\2\2\2OP\3\2\2\2PR\5")
        buf.write("\4\3\2QN\3\2\2\2RU\3\2\2\2SQ\3\2\2\2ST\3\2\2\2TV\3\2\2")
        buf.write("\2US\3\2\2\2VW\5\n\6\2W\\\3\2\2\2XY\5\b\5\2YZ\5\n\6\2")
        buf.write("Z\\\3\2\2\2[K\3\2\2\2[X\3\2\2\2\\\7\3\2\2\2]^\7\4\2\2")
        buf.write("^\t\3\2\2\2_`\7\5\2\2`\13\3\2\2\2ac\5\26\f\2bd\7\17\2")
        buf.write("\2cb\3\2\2\2cd\3\2\2\2de\3\2\2\2ef\5\6\4\2f\r\3\2\2\2")
        buf.write("gh\5\26\f\2hi\7\17\2\2ij\5\36\20\2j\17\3\2\2\2kl\5\26")
        buf.write("\f\2lm\7\17\2\2mn\5,\27\2n\21\3\2\2\2op\5\26\f\2pq\7\17")
        buf.write("\2\2qr\7\16\2\2r\23\3\2\2\2st\5\26\f\2tu\7\17\2\2uv\7")
        buf.write("\13\2\2v\25\3\2\2\2wz\5\30\r\2xz\7\f\2\2yw\3\2\2\2yx\3")
        buf.write("\2\2\2z\27\3\2\2\2{\u0080\7\r\2\2|}\7\6\2\2}\177\7\r\2")
        buf.write("\2~|\3\2\2\2\177\u0082\3\2\2\2\u0080~\3\2\2\2\u0080\u0081")
        buf.write("\3\2\2\2\u0081\31\3\2\2\2\u0082\u0080\3\2\2\2\u0083\u0084")
        buf.write("\7\7\2\2\u0084\33\3\2\2\2\u0085\u0086\7\b\2\2\u0086\35")
        buf.write("\3\2\2\2\u0087\u0088\5\32\16\2\u0088\u008f\5 \21\2\u0089")
        buf.write("\u008b\7\3\2\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2\2")
        buf.write("\u008b\u008c\3\2\2\2\u008c\u008e\5 \21\2\u008d\u008a\3")
        buf.write("\2\2\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090")
        buf.write("\3\2\2\2\u0090\u0092\3\2\2\2\u0091\u008f\3\2\2\2\u0092")
        buf.write("\u0093\5\34\17\2\u0093\u0098\3\2\2\2\u0094\u0095\5\32")
        buf.write("\16\2\u0095\u0096\5\34\17\2\u0096\u0098\3\2\2\2\u0097")
        buf.write("\u0087\3\2\2\2\u0097\u0094\3\2\2\2\u0098\37\3\2\2\2\u0099")
        buf.write("\u009f\5\"\22\2\u009a\u009f\5$\23\2\u009b\u009f\5&\24")
        buf.write("\2\u009c\u009f\5(\25\2\u009d\u009f\5*\26\2\u009e\u0099")
        buf.write("\3\2\2\2\u009e\u009a\3\2\2\2\u009e\u009b\3\2\2\2\u009e")
        buf.write("\u009c\3\2\2\2\u009e\u009d\3\2\2\2\u009f!\3\2\2\2\u00a0")
        buf.write("\u00a1\5,\27\2\u00a1#\3\2\2\2\u00a2\u00a3\7\16\2\2\u00a3")
        buf.write("%\3\2\2\2\u00a4\u00a5\7\13\2\2\u00a5\'\3\2\2\2\u00a6\u00a7")
        buf.write("\5\6\4\2\u00a7)\3\2\2\2\u00a8\u00a9\5\36\20\2\u00a9+\3")
        buf.write("\2\2\2\u00aa\u00ae\7\f\2\2\u00ab\u00ad\5,\27\2\u00ac\u00ab")
        buf.write("\3\2\2\2\u00ad\u00b0\3\2\2\2\u00ae\u00ac\3\2\2\2\u00ae")
        buf.write("\u00af\3\2\2\2\u00af\u00c0\3\2\2\2\u00b0\u00ae\3\2\2\2")
        buf.write("\u00b1\u00b5\5.\30\2\u00b2\u00b4\5,\27\2\u00b3\u00b2\3")
        buf.write("\2\2\2\u00b4\u00b7\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6")
        buf.write("\3\2\2\2\u00b6\u00c0\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8")
        buf.write("\u00bc\7\16\2\2\u00b9\u00bb\5,\27\2\u00ba\u00b9\3\2\2")
        buf.write("\2\u00bb\u00be\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bc\u00bd")
        buf.write("\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00bf")
        buf.write("\u00aa\3\2\2\2\u00bf\u00b1\3\2\2\2\u00bf\u00b8\3\2\2\2")
        buf.write("\u00c0-\3\2\2\2\u00c1\u00c3\t\2\2\2\u00c2\u00c1\3\2\2")
        buf.write("\2\u00c3\u00c4\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5")
        buf.write("\3\2\2\2\u00c5/\3\2\2\2\26\639?BINS[cy\u0080\u008a\u008f")
        buf.write("\u0097\u009e\u00ae\u00b5\u00bc\u00bf\u00c4")
        return buf.getvalue()


class HoconParser ( Parser ):

    grammarFileName = "Hocon.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "','", "'{'", "'}'", "'.'", "'['", "']'", 
                     "'-'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "COMMENT", "NUMBER", "STRING", "PATH_ELEMENT", "REFERENCE", 
                      "KV", "WS" ]

    RULE_hocon = 0
    RULE_prop = 1
    RULE_obj = 2
    RULE_objectBegin = 3
    RULE_objectEnd = 4
    RULE_objectData = 5
    RULE_arrayData = 6
    RULE_stringData = 7
    RULE_referenceData = 8
    RULE_numberData = 9
    RULE_key = 10
    RULE_path = 11
    RULE_arrayBegin = 12
    RULE_arrayEnd = 13
    RULE_array = 14
    RULE_arrayValue = 15
    RULE_arrayString = 16
    RULE_arrayReference = 17
    RULE_arrayNumber = 18
    RULE_arrayObj = 19
    RULE_arrayArray = 20
    RULE_stringValue = 21
    RULE_rawstring = 22

    ruleNames =  [ "hocon", "prop", "obj", "objectBegin", "objectEnd", "objectData", 
                   "arrayData", "stringData", "referenceData", "numberData", 
                   "key", "path", "arrayBegin", "arrayEnd", "array", "arrayValue", 
                   "arrayString", "arrayReference", "arrayNumber", "arrayObj", 
                   "arrayArray", "stringValue", "rawstring" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    COMMENT=8
    NUMBER=9
    STRING=10
    PATH_ELEMENT=11
    REFERENCE=12
    KV=13
    WS=14

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




    class HoconContext(ParserRuleContext):

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

        def obj(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.ObjContext)
            else:
                return self.getTypedRuleContext(HoconParser.ObjContext,i)


        def array(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.ArrayContext)
            else:
                return self.getTypedRuleContext(HoconParser.ArrayContext,i)


        def prop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.PropContext)
            else:
                return self.getTypedRuleContext(HoconParser.PropContext,i)


        def getRuleIndex(self):
            return HoconParser.RULE_hocon

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHocon" ):
                return visitor.visitHocon(self)
            else:
                return visitor.visitChildren(self)




    def hocon(self):

        localctx = HoconParser.HoconContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_hocon)
        self._la = 0 # Token type
        try:
            self.state = 64
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 49
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==HoconParser.T__1:
                    self.state = 46
                    self.obj()
                    self.state = 51
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 55
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==HoconParser.T__4:
                    self.state = 52
                    self.array()
                    self.state = 57
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 61
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==HoconParser.STRING or _la==HoconParser.PATH_ELEMENT:
                    self.state = 58
                    self.prop()
                    self.state = 63
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


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


    class PropContext(ParserRuleContext):

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

        def objectData(self):
            return self.getTypedRuleContext(HoconParser.ObjectDataContext,0)


        def arrayData(self):
            return self.getTypedRuleContext(HoconParser.ArrayDataContext,0)


        def stringData(self):
            return self.getTypedRuleContext(HoconParser.StringDataContext,0)


        def referenceData(self):
            return self.getTypedRuleContext(HoconParser.ReferenceDataContext,0)


        def numberData(self):
            return self.getTypedRuleContext(HoconParser.NumberDataContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_prop

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProp" ):
                return visitor.visitProp(self)
            else:
                return visitor.visitChildren(self)




    def prop(self):

        localctx = HoconParser.PropContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_prop)
        try:
            self.state = 71
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 66
                self.objectData()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 67
                self.arrayData()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 68
                self.stringData()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 69
                self.referenceData()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 70
                self.numberData()
                pass


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


    class ObjContext(ParserRuleContext):

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

        def objectBegin(self):
            return self.getTypedRuleContext(HoconParser.ObjectBeginContext,0)


        def prop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.PropContext)
            else:
                return self.getTypedRuleContext(HoconParser.PropContext,i)


        def objectEnd(self):
            return self.getTypedRuleContext(HoconParser.ObjectEndContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_obj

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObj" ):
                return visitor.visitObj(self)
            else:
                return visitor.visitChildren(self)




    def obj(self):

        localctx = HoconParser.ObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_obj)
        self._la = 0 # Token type
        try:
            self.state = 89
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 73
                self.objectBegin()
                self.state = 74
                self.prop()
                self.state = 81
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << HoconParser.T__0) | (1 << HoconParser.STRING) | (1 << HoconParser.PATH_ELEMENT))) != 0):
                    self.state = 76
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==HoconParser.T__0:
                        self.state = 75
                        self.match(HoconParser.T__0)


                    self.state = 78
                    self.prop()
                    self.state = 83
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 84
                self.objectEnd()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 86
                self.objectBegin()
                self.state = 87
                self.objectEnd()
                pass


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


    class ObjectBeginContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return HoconParser.RULE_objectBegin

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectBegin" ):
                return visitor.visitObjectBegin(self)
            else:
                return visitor.visitChildren(self)




    def objectBegin(self):

        localctx = HoconParser.ObjectBeginContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_objectBegin)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 91
            self.match(HoconParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectEndContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return HoconParser.RULE_objectEnd

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectEnd" ):
                return visitor.visitObjectEnd(self)
            else:
                return visitor.visitChildren(self)




    def objectEnd(self):

        localctx = HoconParser.ObjectEndContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_objectEnd)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 93
            self.match(HoconParser.T__2)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectDataContext(ParserRuleContext):

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

        def key(self):
            return self.getTypedRuleContext(HoconParser.KeyContext,0)


        def obj(self):
            return self.getTypedRuleContext(HoconParser.ObjContext,0)


        def KV(self):
            return self.getToken(HoconParser.KV, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_objectData

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectData" ):
                return visitor.visitObjectData(self)
            else:
                return visitor.visitChildren(self)




    def objectData(self):

        localctx = HoconParser.ObjectDataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_objectData)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 95
            self.key()
            self.state = 97
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==HoconParser.KV:
                self.state = 96
                self.match(HoconParser.KV)


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


    class ArrayDataContext(ParserRuleContext):

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

        def key(self):
            return self.getTypedRuleContext(HoconParser.KeyContext,0)


        def KV(self):
            return self.getToken(HoconParser.KV, 0)

        def array(self):
            return self.getTypedRuleContext(HoconParser.ArrayContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_arrayData

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayData" ):
                return visitor.visitArrayData(self)
            else:
                return visitor.visitChildren(self)




    def arrayData(self):

        localctx = HoconParser.ArrayDataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_arrayData)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 101
            self.key()
            self.state = 102
            self.match(HoconParser.KV)
            self.state = 103
            self.array()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringDataContext(ParserRuleContext):

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

        def key(self):
            return self.getTypedRuleContext(HoconParser.KeyContext,0)


        def KV(self):
            return self.getToken(HoconParser.KV, 0)

        def stringValue(self):
            return self.getTypedRuleContext(HoconParser.StringValueContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_stringData

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringData" ):
                return visitor.visitStringData(self)
            else:
                return visitor.visitChildren(self)




    def stringData(self):

        localctx = HoconParser.StringDataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_stringData)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.key()
            self.state = 106
            self.match(HoconParser.KV)
            self.state = 107
            self.stringValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReferenceDataContext(ParserRuleContext):

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

        def key(self):
            return self.getTypedRuleContext(HoconParser.KeyContext,0)


        def KV(self):
            return self.getToken(HoconParser.KV, 0)

        def REFERENCE(self):
            return self.getToken(HoconParser.REFERENCE, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_referenceData

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReferenceData" ):
                return visitor.visitReferenceData(self)
            else:
                return visitor.visitChildren(self)




    def referenceData(self):

        localctx = HoconParser.ReferenceDataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_referenceData)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 109
            self.key()
            self.state = 110
            self.match(HoconParser.KV)
            self.state = 111
            self.match(HoconParser.REFERENCE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberDataContext(ParserRuleContext):

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

        def key(self):
            return self.getTypedRuleContext(HoconParser.KeyContext,0)


        def KV(self):
            return self.getToken(HoconParser.KV, 0)

        def NUMBER(self):
            return self.getToken(HoconParser.NUMBER, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_numberData

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumberData" ):
                return visitor.visitNumberData(self)
            else:
                return visitor.visitChildren(self)




    def numberData(self):

        localctx = HoconParser.NumberDataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_numberData)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 113
            self.key()
            self.state = 114
            self.match(HoconParser.KV)
            self.state = 115
            self.match(HoconParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KeyContext(ParserRuleContext):

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

        def path(self):
            return self.getTypedRuleContext(HoconParser.PathContext,0)


        def STRING(self):
            return self.getToken(HoconParser.STRING, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_key

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitKey" ):
                return visitor.visitKey(self)
            else:
                return visitor.visitChildren(self)




    def key(self):

        localctx = HoconParser.KeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_key)
        try:
            self.state = 119
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [HoconParser.PATH_ELEMENT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 117
                self.path()
                pass
            elif token in [HoconParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 118
                self.match(HoconParser.STRING)
                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 PathContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return HoconParser.RULE_path

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPath" ):
                return visitor.visitPath(self)
            else:
                return visitor.visitChildren(self)




    def path(self):

        localctx = HoconParser.PathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_path)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 121
            self.match(HoconParser.PATH_ELEMENT)
            self.state = 126
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==HoconParser.T__3:
                self.state = 122
                self.match(HoconParser.T__3)
                self.state = 123
                self.match(HoconParser.PATH_ELEMENT)
                self.state = 128
                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 ArrayBeginContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return HoconParser.RULE_arrayBegin

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayBegin" ):
                return visitor.visitArrayBegin(self)
            else:
                return visitor.visitChildren(self)




    def arrayBegin(self):

        localctx = HoconParser.ArrayBeginContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_arrayBegin)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 129
            self.match(HoconParser.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 ArrayEndContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return HoconParser.RULE_arrayEnd

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayEnd" ):
                return visitor.visitArrayEnd(self)
            else:
                return visitor.visitChildren(self)




    def arrayEnd(self):

        localctx = HoconParser.ArrayEndContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_arrayEnd)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 131
            self.match(HoconParser.T__5)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrayContext(ParserRuleContext):

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

        def arrayBegin(self):
            return self.getTypedRuleContext(HoconParser.ArrayBeginContext,0)


        def arrayValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.ArrayValueContext)
            else:
                return self.getTypedRuleContext(HoconParser.ArrayValueContext,i)


        def arrayEnd(self):
            return self.getTypedRuleContext(HoconParser.ArrayEndContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_array

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArray" ):
                return visitor.visitArray(self)
            else:
                return visitor.visitChildren(self)




    def array(self):

        localctx = HoconParser.ArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_array)
        self._la = 0 # Token type
        try:
            self.state = 149
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 133
                self.arrayBegin()
                self.state = 134
                self.arrayValue()
                self.state = 141
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << HoconParser.T__0) | (1 << HoconParser.T__1) | (1 << HoconParser.T__4) | (1 << HoconParser.T__6) | (1 << HoconParser.NUMBER) | (1 << HoconParser.STRING) | (1 << HoconParser.PATH_ELEMENT) | (1 << HoconParser.REFERENCE))) != 0):
                    self.state = 136
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==HoconParser.T__0:
                        self.state = 135
                        self.match(HoconParser.T__0)


                    self.state = 138
                    self.arrayValue()
                    self.state = 143
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 144
                self.arrayEnd()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 146
                self.arrayBegin()
                self.state = 147
                self.arrayEnd()
                pass


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


    class ArrayValueContext(ParserRuleContext):

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

        def arrayString(self):
            return self.getTypedRuleContext(HoconParser.ArrayStringContext,0)


        def arrayReference(self):
            return self.getTypedRuleContext(HoconParser.ArrayReferenceContext,0)


        def arrayNumber(self):
            return self.getTypedRuleContext(HoconParser.ArrayNumberContext,0)


        def arrayObj(self):
            return self.getTypedRuleContext(HoconParser.ArrayObjContext,0)


        def arrayArray(self):
            return self.getTypedRuleContext(HoconParser.ArrayArrayContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_arrayValue

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayValue" ):
                return visitor.visitArrayValue(self)
            else:
                return visitor.visitChildren(self)




    def arrayValue(self):

        localctx = HoconParser.ArrayValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_arrayValue)
        try:
            self.state = 156
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 151
                self.arrayString()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 152
                self.arrayReference()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 153
                self.arrayNumber()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 154
                self.arrayObj()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 155
                self.arrayArray()
                pass


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


    class ArrayStringContext(ParserRuleContext):

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

        def stringValue(self):
            return self.getTypedRuleContext(HoconParser.StringValueContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_arrayString

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayString" ):
                return visitor.visitArrayString(self)
            else:
                return visitor.visitChildren(self)




    def arrayString(self):

        localctx = HoconParser.ArrayStringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_arrayString)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 158
            self.stringValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrayReferenceContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(HoconParser.REFERENCE, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_arrayReference

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayReference" ):
                return visitor.visitArrayReference(self)
            else:
                return visitor.visitChildren(self)




    def arrayReference(self):

        localctx = HoconParser.ArrayReferenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_arrayReference)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 160
            self.match(HoconParser.REFERENCE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrayNumberContext(ParserRuleContext):

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

        def NUMBER(self):
            return self.getToken(HoconParser.NUMBER, 0)

        def getRuleIndex(self):
            return HoconParser.RULE_arrayNumber

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayNumber" ):
                return visitor.visitArrayNumber(self)
            else:
                return visitor.visitChildren(self)




    def arrayNumber(self):

        localctx = HoconParser.ArrayNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_arrayNumber)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 162
            self.match(HoconParser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrayObjContext(ParserRuleContext):

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

        def obj(self):
            return self.getTypedRuleContext(HoconParser.ObjContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_arrayObj

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayObj" ):
                return visitor.visitArrayObj(self)
            else:
                return visitor.visitChildren(self)




    def arrayObj(self):

        localctx = HoconParser.ArrayObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_arrayObj)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 164
            self.obj()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrayArrayContext(ParserRuleContext):

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

        def array(self):
            return self.getTypedRuleContext(HoconParser.ArrayContext,0)


        def getRuleIndex(self):
            return HoconParser.RULE_arrayArray

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArrayArray" ):
                return visitor.visitArrayArray(self)
            else:
                return visitor.visitChildren(self)




    def arrayArray(self):

        localctx = HoconParser.ArrayArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_arrayArray)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 166
            self.array()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringValueContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return HoconParser.RULE_stringValue

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



    class V_rawstringContext(StringValueContext):

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

        def rawstring(self):
            return self.getTypedRuleContext(HoconParser.RawstringContext,0)

        def stringValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.StringValueContext)
            else:
                return self.getTypedRuleContext(HoconParser.StringValueContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitV_rawstring" ):
                return visitor.visitV_rawstring(self)
            else:
                return visitor.visitChildren(self)


    class V_referenceContext(StringValueContext):

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

        def REFERENCE(self):
            return self.getToken(HoconParser.REFERENCE, 0)
        def stringValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.StringValueContext)
            else:
                return self.getTypedRuleContext(HoconParser.StringValueContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitV_reference" ):
                return visitor.visitV_reference(self)
            else:
                return visitor.visitChildren(self)


    class V_stringContext(StringValueContext):

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

        def STRING(self):
            return self.getToken(HoconParser.STRING, 0)
        def stringValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(HoconParser.StringValueContext)
            else:
                return self.getTypedRuleContext(HoconParser.StringValueContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitV_string" ):
                return visitor.visitV_string(self)
            else:
                return visitor.visitChildren(self)



    def stringValue(self):

        localctx = HoconParser.StringValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_stringValue)
        try:
            self.state = 189
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [HoconParser.STRING]:
                localctx = HoconParser.V_stringContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 168
                self.match(HoconParser.STRING)
                self.state = 172
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 169
                        self.stringValue() 
                    self.state = 174
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,15,self._ctx)

                pass
            elif token in [HoconParser.T__6, HoconParser.PATH_ELEMENT]:
                localctx = HoconParser.V_rawstringContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 175
                self.rawstring()
                self.state = 179
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 176
                        self.stringValue() 
                    self.state = 181
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,16,self._ctx)

                pass
            elif token in [HoconParser.REFERENCE]:
                localctx = HoconParser.V_referenceContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 182
                self.match(HoconParser.REFERENCE)
                self.state = 186
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,17,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 183
                        self.stringValue() 
                    self.state = 188
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,17,self._ctx)

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

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

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

        def getRuleIndex(self):
            return HoconParser.RULE_rawstring

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRawstring" ):
                return visitor.visitRawstring(self)
            else:
                return visitor.visitChildren(self)




    def rawstring(self):

        localctx = HoconParser.RawstringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_rawstring)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 191
                    _la = self._input.LA(1)
                    if not(_la==HoconParser.T__6 or _la==HoconParser.PATH_ELEMENT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

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

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