# Generated from JavadocParser.g4 by ANTLR 4.7.2
# encoding: utf-8
import sys
from io import StringIO
from typing.io import TextIO

from antlr4 import *


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\16")
        buf.write("\u00f2\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\3\2\3\2\3\2\7")
        buf.write("\2\62\n\2\f\2\16\2\65\13\2\3\2\3\2\3\2\3\2\3\2\7\2<\n")
        buf.write("\2\f\2\16\2?\13\2\3\2\3\2\3\2\5\2D\n\2\3\3\3\3\7\3H\n")
        buf.write("\3\f\3\16\3K\13\3\3\3\7\3N\n\3\f\3\16\3Q\13\3\3\3\3\3")
        buf.write("\3\3\6\3V\n\3\r\3\16\3W\3\3\7\3[\n\3\f\3\16\3^\13\3\3")
        buf.write("\3\3\3\5\3b\n\3\3\4\3\4\3\5\3\5\6\5h\n\5\r\5\16\5i\3\5")
        buf.write("\3\5\7\5n\n\5\f\5\16\5q\13\5\3\6\3\6\7\6u\n\6\f\6\16\6")
        buf.write("x\13\6\3\6\3\6\7\6|\n\6\f\6\16\6\177\13\6\5\6\u0081\n")
        buf.write("\6\3\7\5\7\u0084\n\7\3\7\6\7\u0087\n\7\r\7\16\7\u0088")
        buf.write("\3\7\3\7\3\7\7\7\u008e\n\7\f\7\16\7\u0091\13\7\3\b\3\b")
        buf.write("\3\t\3\t\5\t\u0097\n\t\3\n\3\n\3\n\6\n\u009c\n\n\r\n\16")
        buf.write("\n\u009d\3\13\3\13\3\f\6\f\u00a3\n\f\r\f\16\f\u00a4\3")
        buf.write("\r\5\r\u00a8\n\r\3\r\3\r\3\r\5\r\u00ad\n\r\3\r\7\r\u00b0")
        buf.write("\n\r\f\r\16\r\u00b3\13\r\3\16\3\16\3\17\3\17\3\17\5\17")
        buf.write("\u00ba\n\17\3\20\6\20\u00bd\n\20\r\20\16\20\u00be\3\21")
        buf.write("\3\21\3\22\3\22\3\22\7\22\u00c6\n\22\f\22\16\22\u00c9")
        buf.write("\13\22\3\22\5\22\u00cc\n\22\3\22\3\22\3\23\3\23\3\24\6")
        buf.write("\24\u00d3\n\24\r\24\16\24\u00d4\3\25\3\25\7\25\u00d9\n")
        buf.write("\25\f\25\16\25\u00dc\13\25\3\25\3\25\3\26\3\26\3\26\7")
        buf.write("\26\u00e3\n\26\f\26\16\26\u00e6\13\26\3\26\7\26\u00e9")
        buf.write("\n\26\f\26\16\26\u00ec\13\26\5\26\u00ee\n\26\3\27\3\27")
        buf.write('\3\27\2\2\30\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 "')
        buf.write("$&(*,\2\6\3\2\4\5\6\2\3\3\6\6\b\t\r\16\6\2\3\3\5\6\b\t")
        buf.write("\r\16\4\2\3\6\b\t\2\u0101\2C\3\2\2\2\4a\3\2\2\2\6c\3\2")
        buf.write("\2\2\be\3\2\2\2\n\u0080\3\2\2\2\f\u0083\3\2\2\2\16\u0092")
        buf.write("\3\2\2\2\20\u0096\3\2\2\2\22\u009b\3\2\2\2\24\u009f\3")
        buf.write("\2\2\2\26\u00a2\3\2\2\2\30\u00a7\3\2\2\2\32\u00b4\3\2")
        buf.write("\2\2\34\u00b9\3\2\2\2\36\u00bc\3\2\2\2 \u00c0\3\2\2\2")
        buf.write('"\u00c2\3\2\2\2$\u00cf\3\2\2\2&\u00d2\3\2\2\2(\u00d6')
        buf.write("\3\2\2\2*\u00ed\3\2\2\2,\u00ef\3\2\2\2.D\7\2\2\3/\63\7")
        buf.write("\n\2\2\60\62\5\6\4\2\61\60\3\2\2\2\62\65\3\2\2\2\63\61")
        buf.write("\3\2\2\2\63\64\3\2\2\2\64\66\3\2\2\2\65\63\3\2\2\2\66")
        buf.write("\67\5\4\3\2\678\7\13\2\289\7\2\2\39D\3\2\2\2:<\5\6\4\2")
        buf.write(";:\3\2\2\2<?\3\2\2\2=;\3\2\2\2=>\3\2\2\2>@\3\2\2\2?=\3")
        buf.write("\2\2\2@A\5\4\3\2AB\7\2\2\3BD\3\2\2\2C.\3\2\2\2C/\3\2\2")
        buf.write("\2C=\3\2\2\2D\3\3\2\2\2EI\5\b\5\2FH\5\6\4\2GF\3\2\2\2")
        buf.write("HK\3\2\2\2IG\3\2\2\2IJ\3\2\2\2Jb\3\2\2\2KI\3\2\2\2LN\5")
        buf.write("\6\4\2ML\3\2\2\2NQ\3\2\2\2OM\3\2\2\2OP\3\2\2\2PR\3\2\2")
        buf.write("\2QO\3\2\2\2Rb\5\26\f\2SU\5\b\5\2TV\7\4\2\2UT\3\2\2\2")
        buf.write("VW\3\2\2\2WU\3\2\2\2WX\3\2\2\2X\\\3\2\2\2Y[\5\6\4\2ZY")
        buf.write("\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]_\3\2\2\2^\\")
        buf.write("\3\2\2\2_`\5\26\f\2`b\3\2\2\2aE\3\2\2\2aO\3\2\2\2aS\3")
        buf.write("\2\2\2b\5\3\2\2\2cd\t\2\2\2d\7\3\2\2\2eo\5\n\6\2fh\5\24")
        buf.write("\13\2gf\3\2\2\2hi\3\2\2\2ig\3\2\2\2ij\3\2\2\2jk\3\2\2")
        buf.write("\2kl\5\n\6\2ln\3\2\2\2mg\3\2\2\2nq\3\2\2\2om\3\2\2\2o")
        buf.write("p\3\2\2\2p\t\3\2\2\2qo\3\2\2\2rv\5\f\7\2su\5\20\t\2ts")
        buf.write("\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2w\u0081\3\2\2\2")
        buf.write('xv\3\2\2\2y}\5"\22\2z|\5\20\t\2{z\3\2\2\2|\177\3\2\2')
        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080")
        buf.write("r\3\2\2\2\u0080y\3\2\2\2\u0081\13\3\2\2\2\u0082\u0084")
        buf.write("\7\5\2\2\u0083\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084")
        buf.write("\u0086\3\2\2\2\u0085\u0087\5\16\b\2\u0086\u0085\3\2\2")
        buf.write("\2\u0087\u0088\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089")
        buf.write("\3\2\2\2\u0089\u008f\3\2\2\2\u008a\u008e\5\16\b\2\u008b")
        buf.write("\u008e\7\5\2\2\u008c\u008e\7\7\2\2\u008d\u008a\3\2\2\2")
        buf.write("\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2\u008e\u0091\3")
        buf.write("\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090\r")
        buf.write("\3\2\2\2\u0091\u008f\3\2\2\2\u0092\u0093\t\3\2\2\u0093")
        buf.write('\17\3\2\2\2\u0094\u0097\5"\22\2\u0095\u0097\5\22\n\2')
        buf.write("\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2\2\u0097\21\3\2")
        buf.write("\2\2\u0098\u009c\5\16\b\2\u0099\u009c\7\5\2\2\u009a\u009c")
        buf.write("\7\7\2\2\u009b\u0098\3\2\2\2\u009b\u0099\3\2\2\2\u009b")
        buf.write("\u009a\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009b\3\2\2\2")
        buf.write("\u009d\u009e\3\2\2\2\u009e\23\3\2\2\2\u009f\u00a0\7\4")
        buf.write("\2\2\u00a0\25\3\2\2\2\u00a1\u00a3\5\30\r\2\u00a2\u00a1")
        buf.write("\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a4")
        buf.write("\u00a5\3\2\2\2\u00a5\27\3\2\2\2\u00a6\u00a8\7\5\2\2\u00a7")
        buf.write("\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2")
        buf.write("\u00a9\u00aa\7\7\2\2\u00aa\u00ac\5\32\16\2\u00ab\u00ad")
        buf.write("\7\5\2\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad")
        buf.write("\u00b1\3\2\2\2\u00ae\u00b0\5\34\17\2\u00af\u00ae\3\2\2")
        buf.write("\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2")
        buf.write("\3\2\2\2\u00b2\31\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5")
        buf.write("\7\3\2\2\u00b5\33\3\2\2\2\u00b6\u00ba\5\36\20\2\u00b7")
        buf.write('\u00ba\5"\22\2\u00b8\u00ba\7\4\2\2\u00b9\u00b6\3\2\2')
        buf.write("\2\u00b9\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2\u00ba\35\3")
        buf.write("\2\2\2\u00bb\u00bd\5 \21\2\u00bc\u00bb\3\2\2\2\u00bd\u00be")
        buf.write("\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf")
        buf.write("\37\3\2\2\2\u00c0\u00c1\t\4\2\2\u00c1!\3\2\2\2\u00c2\u00c3")
        buf.write("\7\f\2\2\u00c3\u00c7\5$\23\2\u00c4\u00c6\7\5\2\2\u00c5")
        buf.write("\u00c4\3\2\2\2\u00c6\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2")
        buf.write("\u00c7\u00c8\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3")
        buf.write("\2\2\2\u00ca\u00cc\5&\24\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc")
        buf.write("\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\7\16\2\2\u00ce")
        buf.write("#\3\2\2\2\u00cf\u00d0\7\3\2\2\u00d0%\3\2\2\2\u00d1\u00d3")
        buf.write("\5*\26\2\u00d2\u00d1\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4")
        buf.write("\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5'\3\2\2\2\u00d6")
        buf.write("\u00da\7\r\2\2\u00d7\u00d9\5*\26\2\u00d8\u00d7\3\2\2\2")
        buf.write("\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3")
        buf.write("\2\2\2\u00db\u00dd\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00de")
        buf.write("\7\16\2\2\u00de)\3\2\2\2\u00df\u00ee\5(\25\2\u00e0\u00ea")
        buf.write("\5,\27\2\u00e1\u00e3\7\4\2\2\u00e2\u00e1\3\2\2\2\u00e3")
        buf.write("\u00e6\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2")
        buf.write("\u00e5\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\5")
        buf.write(",\27\2\u00e8\u00e4\3\2\2\2\u00e9\u00ec\3\2\2\2\u00ea\u00e8")
        buf.write("\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ee\3\2\2\2\u00ec")
        buf.write("\u00ea\3\2\2\2\u00ed\u00df\3\2\2\2\u00ed\u00e0\3\2\2\2")
        buf.write("\u00ee+\3\2\2\2\u00ef\u00f0\t\5\2\2\u00f0-\3\2\2\2#\63")
        buf.write("=CIOW\\aiov}\u0080\u0083\u0088\u008d\u008f\u0096\u009b")
        buf.write("\u009d\u00a4\u00a7\u00ac\u00b1\u00b9\u00be\u00c7\u00cb")
        buf.write("\u00d4\u00da\u00e4\u00ea\u00ed")
        return buf.getvalue()


class JavadocParser(Parser):

    grammarFileName = "JavadocParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "'@'",
        "'*'",
        "'/'",
        "<INVALID>",
        "<INVALID>",
        "'{@'",
        "'{'",
        "'}'",
    ]

    symbolicNames = [
        "<INVALID>",
        "NAME",
        "NEWLINE",
        "SPACE",
        "TEXT_CONTENT",
        "AT",
        "STAR",
        "SLASH",
        "JAVADOC_START",
        "JAVADOC_END",
        "INLINE_TAG_START",
        "BRACE_OPEN",
        "BRACE_CLOSE",
    ]

    RULE_documentation = 0
    RULE_documentationContent = 1
    RULE_skipWhitespace = 2
    RULE_description = 3
    RULE_descriptionLine = 4
    RULE_descriptionLineStart = 5
    RULE_descriptionLineNoSpaceNoAt = 6
    RULE_descriptionLineElement = 7
    RULE_descriptionLineText = 8
    RULE_descriptionNewline = 9
    RULE_tagSection = 10
    RULE_blockTag = 11
    RULE_blockTagName = 12
    RULE_blockTagContent = 13
    RULE_blockTagText = 14
    RULE_blockTagTextElement = 15
    RULE_inlineTag = 16
    RULE_inlineTagName = 17
    RULE_inlineTagContent = 18
    RULE_braceExpression = 19
    RULE_braceContent = 20
    RULE_braceText = 21

    ruleNames = [
        "documentation",
        "documentationContent",
        "skipWhitespace",
        "description",
        "descriptionLine",
        "descriptionLineStart",
        "descriptionLineNoSpaceNoAt",
        "descriptionLineElement",
        "descriptionLineText",
        "descriptionNewline",
        "tagSection",
        "blockTag",
        "blockTagName",
        "blockTagContent",
        "blockTagText",
        "blockTagTextElement",
        "inlineTag",
        "inlineTagName",
        "inlineTagContent",
        "braceExpression",
        "braceContent",
        "braceText",
    ]

    EOF = Token.EOF
    NAME = 1
    NEWLINE = 2
    SPACE = 3
    TEXT_CONTENT = 4
    AT = 5
    STAR = 6
    SLASH = 7
    JAVADOC_START = 8
    JAVADOC_END = 9
    INLINE_TAG_START = 10
    BRACE_OPEN = 11
    BRACE_CLOSE = 12

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

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

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

        def JAVADOC_START(self):
            return self.getToken(JavadocParser.JAVADOC_START, 0)

        def documentationContent(self):
            return self.getTypedRuleContext(JavadocParser.DocumentationContentContext, 0)

        def JAVADOC_END(self):
            return self.getToken(JavadocParser.JAVADOC_END, 0)

        def skipWhitespace(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.SkipWhitespaceContext)
            else:
                return self.getTypedRuleContext(JavadocParser.SkipWhitespaceContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_documentation

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

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

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

    def documentation(self):

        localctx = JavadocParser.DocumentationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_documentation)
        try:
            self.state = 65
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavadocParser.EOF]:
                self.enterOuterAlt(localctx, 1)
                self.state = 44
                self.match(JavadocParser.EOF)
                pass
            elif token in [JavadocParser.JAVADOC_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 45
                self.match(JavadocParser.JAVADOC_START)
                self.state = 49
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 46
                        self.skipWhitespace()
                    self.state = 51
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)

                self.state = 52
                self.documentationContent()
                self.state = 53
                self.match(JavadocParser.JAVADOC_END)
                self.state = 54
                self.match(JavadocParser.EOF)
                pass
            elif token in [
                JavadocParser.NAME,
                JavadocParser.NEWLINE,
                JavadocParser.SPACE,
                JavadocParser.TEXT_CONTENT,
                JavadocParser.AT,
                JavadocParser.STAR,
                JavadocParser.SLASH,
                JavadocParser.INLINE_TAG_START,
                JavadocParser.BRACE_OPEN,
                JavadocParser.BRACE_CLOSE,
            ]:
                self.enterOuterAlt(localctx, 3)
                self.state = 59
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 1, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 56
                        self.skipWhitespace()
                    self.state = 61
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 1, self._ctx)

                self.state = 62
                self.documentationContent()
                self.state = 63
                self.match(JavadocParser.EOF)
                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 DocumentationContentContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def description(self):
            return self.getTypedRuleContext(JavadocParser.DescriptionContext, 0)

        def skipWhitespace(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.SkipWhitespaceContext)
            else:
                return self.getTypedRuleContext(JavadocParser.SkipWhitespaceContext, i)

        def tagSection(self):
            return self.getTypedRuleContext(JavadocParser.TagSectionContext, 0)

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

        def getRuleIndex(self):
            return JavadocParser.RULE_documentationContent

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

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

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

    def documentationContent(self):

        localctx = JavadocParser.DocumentationContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_documentationContent)
        self._la = 0  # Token type
        try:
            self.state = 95
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 7, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 67
                self.description()
                self.state = 71
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavadocParser.NEWLINE or _la == JavadocParser.SPACE:
                    self.state = 68
                    self.skipWhitespace()
                    self.state = 73
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 77
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 4, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 74
                        self.skipWhitespace()
                    self.state = 79
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 4, self._ctx)

                self.state = 80
                self.tagSection()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 81
                self.description()
                self.state = 83
                self._errHandler.sync(self)
                _alt = 1
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 82
                        self.match(JavadocParser.NEWLINE)

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

                self.state = 90
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 87
                        self.skipWhitespace()
                    self.state = 92
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)

                self.state = 93
                self.tagSection()
                pass

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

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

        def SPACE(self):
            return self.getToken(JavadocParser.SPACE, 0)

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

        def getRuleIndex(self):
            return JavadocParser.RULE_skipWhitespace

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

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

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

    def skipWhitespace(self):

        localctx = JavadocParser.SkipWhitespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_skipWhitespace)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 97
            _la = self._input.LA(1)
            if not (_la == JavadocParser.NEWLINE or _la == JavadocParser.SPACE):
                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 DescriptionContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def descriptionLine(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.DescriptionLineContext)
            else:
                return self.getTypedRuleContext(JavadocParser.DescriptionLineContext, i)

        def descriptionNewline(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.DescriptionNewlineContext)
            else:
                return self.getTypedRuleContext(JavadocParser.DescriptionNewlineContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_description

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

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

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

    def description(self):

        localctx = JavadocParser.DescriptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_description)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 99
            self.descriptionLine()
            self.state = 109
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 9, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 101
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 100
                        self.descriptionNewline()
                        self.state = 103
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la == JavadocParser.NEWLINE):
                            break

                    self.state = 105
                    self.descriptionLine()
                self.state = 111
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 9, 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 DescriptionLineContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def descriptionLineStart(self):
            return self.getTypedRuleContext(JavadocParser.DescriptionLineStartContext, 0)

        def descriptionLineElement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.DescriptionLineElementContext)
            else:
                return self.getTypedRuleContext(JavadocParser.DescriptionLineElementContext, i)

        def inlineTag(self):
            return self.getTypedRuleContext(JavadocParser.InlineTagContext, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionLine

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

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

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

    def descriptionLine(self):

        localctx = JavadocParser.DescriptionLineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_descriptionLine)
        try:
            self.state = 126
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavadocParser.NAME,
                JavadocParser.SPACE,
                JavadocParser.TEXT_CONTENT,
                JavadocParser.STAR,
                JavadocParser.SLASH,
                JavadocParser.BRACE_OPEN,
                JavadocParser.BRACE_CLOSE,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 112
                self.descriptionLineStart()
                self.state = 116
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 10, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 113
                        self.descriptionLineElement()
                    self.state = 118
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 10, self._ctx)

                pass
            elif token in [JavadocParser.INLINE_TAG_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 119
                self.inlineTag()
                self.state = 123
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 11, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 120
                        self.descriptionLineElement()
                    self.state = 125
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 11, 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 DescriptionLineStartContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

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

        def descriptionLineNoSpaceNoAt(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.DescriptionLineNoSpaceNoAtContext)
            else:
                return self.getTypedRuleContext(JavadocParser.DescriptionLineNoSpaceNoAtContext, i)

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

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionLineStart

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

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

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

    def descriptionLineStart(self):

        localctx = JavadocParser.DescriptionLineStartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_descriptionLineStart)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 129
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavadocParser.SPACE:
                self.state = 128
                self.match(JavadocParser.SPACE)

            self.state = 132
            self._errHandler.sync(self)
            _alt = 1
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 131
                    self.descriptionLineNoSpaceNoAt()

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

            self.state = 141
            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 = 139
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [
                        JavadocParser.NAME,
                        JavadocParser.TEXT_CONTENT,
                        JavadocParser.STAR,
                        JavadocParser.SLASH,
                        JavadocParser.BRACE_OPEN,
                        JavadocParser.BRACE_CLOSE,
                    ]:
                        self.state = 136
                        self.descriptionLineNoSpaceNoAt()
                        pass
                    elif token in [JavadocParser.SPACE]:
                        self.state = 137
                        self.match(JavadocParser.SPACE)
                        pass
                    elif token in [JavadocParser.AT]:
                        self.state = 138
                        self.match(JavadocParser.AT)
                        pass
                    else:
                        raise NoViableAltException(self)

                self.state = 143
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 16, self._ctx)

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

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

        def TEXT_CONTENT(self):
            return self.getToken(JavadocParser.TEXT_CONTENT, 0)

        def NAME(self):
            return self.getToken(JavadocParser.NAME, 0)

        def STAR(self):
            return self.getToken(JavadocParser.STAR, 0)

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

        def BRACE_OPEN(self):
            return self.getToken(JavadocParser.BRACE_OPEN, 0)

        def BRACE_CLOSE(self):
            return self.getToken(JavadocParser.BRACE_CLOSE, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionLineNoSpaceNoAt

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

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

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

    def descriptionLineNoSpaceNoAt(self):

        localctx = JavadocParser.DescriptionLineNoSpaceNoAtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_descriptionLineNoSpaceNoAt)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 144
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavadocParser.NAME)
                            | (1 << JavadocParser.TEXT_CONTENT)
                            | (1 << JavadocParser.STAR)
                            | (1 << JavadocParser.SLASH)
                            | (1 << JavadocParser.BRACE_OPEN)
                            | (1 << JavadocParser.BRACE_CLOSE)
                        )
                    )
                    != 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 DescriptionLineElementContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inlineTag(self):
            return self.getTypedRuleContext(JavadocParser.InlineTagContext, 0)

        def descriptionLineText(self):
            return self.getTypedRuleContext(JavadocParser.DescriptionLineTextContext, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionLineElement

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

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

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

    def descriptionLineElement(self):

        localctx = JavadocParser.DescriptionLineElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_descriptionLineElement)
        try:
            self.state = 148
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavadocParser.INLINE_TAG_START]:
                self.enterOuterAlt(localctx, 1)
                self.state = 146
                self.inlineTag()
                pass
            elif token in [
                JavadocParser.NAME,
                JavadocParser.SPACE,
                JavadocParser.TEXT_CONTENT,
                JavadocParser.AT,
                JavadocParser.STAR,
                JavadocParser.SLASH,
                JavadocParser.BRACE_OPEN,
                JavadocParser.BRACE_CLOSE,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 147
                self.descriptionLineText()
                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 DescriptionLineTextContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def descriptionLineNoSpaceNoAt(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.DescriptionLineNoSpaceNoAtContext)
            else:
                return self.getTypedRuleContext(JavadocParser.DescriptionLineNoSpaceNoAtContext, i)

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

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

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionLineText

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

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

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

    def descriptionLineText(self):

        localctx = JavadocParser.DescriptionLineTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_descriptionLineText)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 153
            self._errHandler.sync(self)
            _alt = 1
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 153
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [
                        JavadocParser.NAME,
                        JavadocParser.TEXT_CONTENT,
                        JavadocParser.STAR,
                        JavadocParser.SLASH,
                        JavadocParser.BRACE_OPEN,
                        JavadocParser.BRACE_CLOSE,
                    ]:
                        self.state = 150
                        self.descriptionLineNoSpaceNoAt()
                        pass
                    elif token in [JavadocParser.SPACE]:
                        self.state = 151
                        self.match(JavadocParser.SPACE)
                        pass
                    elif token in [JavadocParser.AT]:
                        self.state = 152
                        self.match(JavadocParser.AT)
                        pass
                    else:
                        raise NoViableAltException(self)

                else:
                    raise NoViableAltException(self)
                self.state = 155
                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

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

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

        def getRuleIndex(self):
            return JavadocParser.RULE_descriptionNewline

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

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

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

    def descriptionNewline(self):

        localctx = JavadocParser.DescriptionNewlineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_descriptionNewline)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 157
            self.match(JavadocParser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

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

        def blockTag(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BlockTagContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BlockTagContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_tagSection

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

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

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

    def tagSection(self):

        localctx = JavadocParser.TagSectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_tagSection)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 160
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 159
                self.blockTag()
                self.state = 162
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la == JavadocParser.SPACE or _la == JavadocParser.AT):
                    break

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

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

        def AT(self):
            return self.getToken(JavadocParser.AT, 0)

        def blockTagName(self):
            return self.getTypedRuleContext(JavadocParser.BlockTagNameContext, 0)

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

        def blockTagContent(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BlockTagContentContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BlockTagContentContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_blockTag

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

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

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

    def blockTag(self):

        localctx = JavadocParser.BlockTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_blockTag)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavadocParser.SPACE:
                self.state = 164
                self.match(JavadocParser.SPACE)

            self.state = 167
            self.match(JavadocParser.AT)
            self.state = 168
            self.blockTagName()
            self.state = 170
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 22, self._ctx)
            if la_ == 1:
                self.state = 169
                self.match(JavadocParser.SPACE)

            self.state = 175
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 23, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 172
                    self.blockTagContent()
                self.state = 177
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 23, 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 BlockTagNameContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAME(self):
            return self.getToken(JavadocParser.NAME, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_blockTagName

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

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

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

    def blockTagName(self):

        localctx = JavadocParser.BlockTagNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_blockTagName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self.match(JavadocParser.NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

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

        def blockTagText(self):
            return self.getTypedRuleContext(JavadocParser.BlockTagTextContext, 0)

        def inlineTag(self):
            return self.getTypedRuleContext(JavadocParser.InlineTagContext, 0)

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

        def getRuleIndex(self):
            return JavadocParser.RULE_blockTagContent

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

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

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

    def blockTagContent(self):

        localctx = JavadocParser.BlockTagContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_blockTagContent)
        try:
            self.state = 183
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavadocParser.NAME,
                JavadocParser.SPACE,
                JavadocParser.TEXT_CONTENT,
                JavadocParser.STAR,
                JavadocParser.SLASH,
                JavadocParser.BRACE_OPEN,
                JavadocParser.BRACE_CLOSE,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 180
                self.blockTagText()
                pass
            elif token in [JavadocParser.INLINE_TAG_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 181
                self.inlineTag()
                pass
            elif token in [JavadocParser.NEWLINE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 182
                self.match(JavadocParser.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 BlockTagTextContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def blockTagTextElement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BlockTagTextElementContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BlockTagTextElementContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_blockTagText

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

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

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

    def blockTagText(self):

        localctx = JavadocParser.BlockTagTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_blockTagText)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 186
            self._errHandler.sync(self)
            _alt = 1
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 185
                    self.blockTagTextElement()

                else:
                    raise NoViableAltException(self)
                self.state = 188
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 25, 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 BlockTagTextElementContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TEXT_CONTENT(self):
            return self.getToken(JavadocParser.TEXT_CONTENT, 0)

        def NAME(self):
            return self.getToken(JavadocParser.NAME, 0)

        def SPACE(self):
            return self.getToken(JavadocParser.SPACE, 0)

        def STAR(self):
            return self.getToken(JavadocParser.STAR, 0)

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

        def BRACE_OPEN(self):
            return self.getToken(JavadocParser.BRACE_OPEN, 0)

        def BRACE_CLOSE(self):
            return self.getToken(JavadocParser.BRACE_CLOSE, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_blockTagTextElement

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

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

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

    def blockTagTextElement(self):

        localctx = JavadocParser.BlockTagTextElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_blockTagTextElement)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 190
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavadocParser.NAME)
                            | (1 << JavadocParser.SPACE)
                            | (1 << JavadocParser.TEXT_CONTENT)
                            | (1 << JavadocParser.STAR)
                            | (1 << JavadocParser.SLASH)
                            | (1 << JavadocParser.BRACE_OPEN)
                            | (1 << JavadocParser.BRACE_CLOSE)
                        )
                    )
                    != 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 InlineTagContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INLINE_TAG_START(self):
            return self.getToken(JavadocParser.INLINE_TAG_START, 0)

        def inlineTagName(self):
            return self.getTypedRuleContext(JavadocParser.InlineTagNameContext, 0)

        def BRACE_CLOSE(self):
            return self.getToken(JavadocParser.BRACE_CLOSE, 0)

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

        def inlineTagContent(self):
            return self.getTypedRuleContext(JavadocParser.InlineTagContentContext, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_inlineTag

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

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

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

    def inlineTag(self):

        localctx = JavadocParser.InlineTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_inlineTag)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.match(JavadocParser.INLINE_TAG_START)
            self.state = 193
            self.inlineTagName()
            self.state = 197
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 26, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 194
                    self.match(JavadocParser.SPACE)
                self.state = 199
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 26, self._ctx)

            self.state = 201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3F) == 0 and (
                (1 << _la)
                & (
                    (1 << JavadocParser.NAME)
                    | (1 << JavadocParser.NEWLINE)
                    | (1 << JavadocParser.SPACE)
                    | (1 << JavadocParser.TEXT_CONTENT)
                    | (1 << JavadocParser.STAR)
                    | (1 << JavadocParser.SLASH)
                    | (1 << JavadocParser.BRACE_OPEN)
                )
            ) != 0:
                self.state = 200
                self.inlineTagContent()

            self.state = 203
            self.match(JavadocParser.BRACE_CLOSE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

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

        def NAME(self):
            return self.getToken(JavadocParser.NAME, 0)

        def getRuleIndex(self):
            return JavadocParser.RULE_inlineTagName

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

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

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

    def inlineTagName(self):

        localctx = JavadocParser.InlineTagNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_inlineTagName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 205
            self.match(JavadocParser.NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

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

        def braceContent(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BraceContentContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BraceContentContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_inlineTagContent

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

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

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

    def inlineTagContent(self):

        localctx = JavadocParser.InlineTagContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_inlineTagContent)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 207
                self.braceContent()
                self.state = 210
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << JavadocParser.NAME)
                                | (1 << JavadocParser.NEWLINE)
                                | (1 << JavadocParser.SPACE)
                                | (1 << JavadocParser.TEXT_CONTENT)
                                | (1 << JavadocParser.STAR)
                                | (1 << JavadocParser.SLASH)
                                | (1 << JavadocParser.BRACE_OPEN)
                            )
                        )
                        != 0
                    )
                ):
                    break

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

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

        def BRACE_OPEN(self):
            return self.getToken(JavadocParser.BRACE_OPEN, 0)

        def BRACE_CLOSE(self):
            return self.getToken(JavadocParser.BRACE_CLOSE, 0)

        def braceContent(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BraceContentContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BraceContentContext, i)

        def getRuleIndex(self):
            return JavadocParser.RULE_braceExpression

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

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

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

    def braceExpression(self):

        localctx = JavadocParser.BraceExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_braceExpression)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 212
            self.match(JavadocParser.BRACE_OPEN)
            self.state = 216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((_la) & ~0x3F) == 0 and (
                (1 << _la)
                & (
                    (1 << JavadocParser.NAME)
                    | (1 << JavadocParser.NEWLINE)
                    | (1 << JavadocParser.SPACE)
                    | (1 << JavadocParser.TEXT_CONTENT)
                    | (1 << JavadocParser.STAR)
                    | (1 << JavadocParser.SLASH)
                    | (1 << JavadocParser.BRACE_OPEN)
                )
            ) != 0:
                self.state = 213
                self.braceContent()
                self.state = 218
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 219
            self.match(JavadocParser.BRACE_CLOSE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

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

        def braceExpression(self):
            return self.getTypedRuleContext(JavadocParser.BraceExpressionContext, 0)

        def braceText(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavadocParser.BraceTextContext)
            else:
                return self.getTypedRuleContext(JavadocParser.BraceTextContext, i)

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

        def getRuleIndex(self):
            return JavadocParser.RULE_braceContent

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

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

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

    def braceContent(self):

        localctx = JavadocParser.BraceContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_braceContent)
        try:
            self.state = 235
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavadocParser.BRACE_OPEN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 221
                self.braceExpression()
                pass
            elif token in [
                JavadocParser.NAME,
                JavadocParser.NEWLINE,
                JavadocParser.SPACE,
                JavadocParser.TEXT_CONTENT,
                JavadocParser.STAR,
                JavadocParser.SLASH,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 222
                self.braceText()
                self.state = 232
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 31, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 226
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input, 30, self._ctx)
                        while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                            if _alt == 1:
                                self.state = 223
                                self.match(JavadocParser.NEWLINE)
                            self.state = 228
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input, 30, self._ctx)

                        self.state = 229
                        self.braceText()
                    self.state = 234
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 31, 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 BraceTextContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TEXT_CONTENT(self):
            return self.getToken(JavadocParser.TEXT_CONTENT, 0)

        def NAME(self):
            return self.getToken(JavadocParser.NAME, 0)

        def SPACE(self):
            return self.getToken(JavadocParser.SPACE, 0)

        def STAR(self):
            return self.getToken(JavadocParser.STAR, 0)

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

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

        def getRuleIndex(self):
            return JavadocParser.RULE_braceText

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

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

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

    def braceText(self):

        localctx = JavadocParser.BraceTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_braceText)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavadocParser.NAME)
                            | (1 << JavadocParser.NEWLINE)
                            | (1 << JavadocParser.SPACE)
                            | (1 << JavadocParser.TEXT_CONTENT)
                            | (1 << JavadocParser.STAR)
                            | (1 << JavadocParser.SLASH)
                        )
                    )
                    != 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
