# Generated from aspida.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3-")
        buf.write("\u01c2\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\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \3\2\3\2\3\2\5\2D\n\2\3\2\5\2G\n\2\3\3")
        buf.write("\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\7\7a\n\7\f\7\16")
        buf.write("\7d\13\7\3\b\3\b\3\b\5\bi\n\b\3\b\3\b\3\t\3\t\3\t\3\t")
        buf.write("\3\t\3\t\5\ts\n\t\3\n\3\n\3\n\3\n\3\n\3\n\5\n{\n\n\3\13")
        buf.write("\3\13\3\13\3\13\3\13\3\13\5\13\u0083\n\13\3\f\3\f\3\f")
        buf.write("\3\f\7\f\u0089\n\f\f\f\16\f\u008c\13\f\3\f\3\f\3\f\3\f")
        buf.write("\5\f\u0092\n\f\3\r\3\r\5\r\u0096\n\r\3\16\3\16\7\16\u009a")
        buf.write("\n\16\f\16\16\16\u009d\13\16\3\17\3\17\3\17\3\17\5\17")
        buf.write("\u00a3\n\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\5")
        buf.write("\20\u00ad\n\20\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u00b5")
        buf.write("\n\21\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u00bd\n\22\3")
        buf.write("\23\3\23\3\23\3\23\3\23\3\23\5\23\u00c5\n\23\3\24\3\24")
        buf.write("\7\24\u00c9\n\24\f\24\16\24\u00cc\13\24\3\25\3\25\3\25")
        buf.write("\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u00da")
        buf.write("\n\25\3\26\3\26\3\26\3\26\3\26\3\26\5\26\u00e2\n\26\3")
        buf.write("\27\3\27\3\27\3\27\7\27\u00e8\n\27\f\27\16\27\u00eb\13")
        buf.write("\27\3\27\3\27\3\27\3\27\5\27\u00f1\n\27\3\30\3\30\3\31")
        buf.write("\3\31\3\31\3\31\7\31\u00f9\n\31\f\31\16\31\u00fc\13\31")
        buf.write("\3\31\3\31\3\31\3\31\5\31\u0102\n\31\3\32\3\32\5\32\u0106")
        buf.write("\n\32\3\33\3\33\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\5\35\u0128\n\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u0138\n\35\3\35")
        buf.write("\5\35\u013b\n\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\35\5\35\u0149\n\35\3\35\3\35\3\35")
        buf.write("\5\35\u014e\n\35\3\35\5\35\u0151\n\35\3\35\3\35\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u015d\n\35\3\35")
        buf.write("\3\35\3\35\5\35\u0162\n\35\3\35\3\35\3\35\5\35\u0167\n")
        buf.write("\35\3\35\5\35\u016a\n\35\3\35\3\35\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\35\5\35\u0174\n\35\3\35\3\35\3\35\5\35\u0179\n")
        buf.write("\35\3\35\3\35\3\35\5\35\u017e\n\35\3\35\3\35\3\35\5\35")
        buf.write("\u0183\n\35\3\35\5\35\u0186\n\35\3\35\3\35\3\35\3\35\3")
        buf.write("\35\5\35\u018d\n\35\3\35\3\35\3\35\5\35\u0192\n\35\3\35")
        buf.write("\3\35\3\35\5\35\u0197\n\35\3\35\3\35\3\35\5\35\u019c\n")
        buf.write("\35\3\35\3\35\3\35\5\35\u01a1\n\35\3\35\5\35\u01a4\n\35")
        buf.write("\3\35\3\35\5\35\u01a8\n\35\3\36\3\36\3\36\3\36\3\36\3")
        buf.write("\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u01b7\n\36")
        buf.write("\3\37\3\37\3\37\3\37\3\37\5\37\u01be\n\37\3 \3 \3 \2\2")
        buf.write("!\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
        buf.write("\64\668:<>\2\4\3\2+-\3\2 !\2\u01e1\2@\3\2\2\2\4H\3\2\2")
        buf.write("\2\6N\3\2\2\2\bR\3\2\2\2\nX\3\2\2\2\f^\3\2\2\2\16h\3\2")
        buf.write("\2\2\20r\3\2\2\2\22z\3\2\2\2\24\u0082\3\2\2\2\26\u0091")
        buf.write("\3\2\2\2\30\u0095\3\2\2\2\32\u0097\3\2\2\2\34\u00a2\3")
        buf.write("\2\2\2\36\u00ac\3\2\2\2 \u00b4\3\2\2\2\"\u00bc\3\2\2\2")
        buf.write("$\u00c4\3\2\2\2&\u00c6\3\2\2\2(\u00d9\3\2\2\2*\u00e1\3")
        buf.write("\2\2\2,\u00f0\3\2\2\2.\u00f2\3\2\2\2\60\u0101\3\2\2\2")
        buf.write("\62\u0105\3\2\2\2\64\u0107\3\2\2\2\66\u0109\3\2\2\28\u01a7")
        buf.write("\3\2\2\2:\u01b6\3\2\2\2<\u01bd\3\2\2\2>\u01bf\3\2\2\2")
        buf.write("@A\5\4\3\2AC\5\6\4\2BD\5\b\5\2CB\3\2\2\2CD\3\2\2\2DF\3")
        buf.write("\2\2\2EG\5\n\6\2FE\3\2\2\2FG\3\2\2\2G\3\3\2\2\2HI\7\'")
        buf.write("\2\2IJ\7\3\2\2JK\7\4\2\2KL\5\f\7\2LM\7\5\2\2M\5\3\2\2")
        buf.write("\2NO\7(\2\2OP\7\3\2\2PQ\5\26\f\2Q\7\3\2\2\2RS\7)\2\2S")
        buf.write("T\7\3\2\2TU\7\4\2\2UV\5\32\16\2VW\7\5\2\2W\t\3\2\2\2X")
        buf.write("Y\7*\2\2YZ\7\3\2\2Z[\7\4\2\2[\\\5&\24\2\\]\7\5\2\2]\13")
        buf.write("\3\2\2\2^b\5\16\b\2_a\5\16\b\2`_\3\2\2\2ad\3\2\2\2b`\3")
        buf.write("\2\2\2bc\3\2\2\2c\r\3\2\2\2db\3\2\2\2ei\5\20\t\2fi\5\22")
        buf.write("\n\2gi\5\24\13\2he\3\2\2\2hf\3\2\2\2hg\3\2\2\2ij\3\2\2")
        buf.write("\2jk\7&\2\2k\17\3\2\2\2lm\7\6\2\2mn\7\3\2\2ns\7\36\2\2")
        buf.write("op\7\7\2\2pq\7\3\2\2qs\7\36\2\2rl\3\2\2\2ro\3\2\2\2s\21")
        buf.write("\3\2\2\2tu\7\b\2\2uv\7\3\2\2v{\t\2\2\2wx\7\t\2\2xy\7\3")
        buf.write("\2\2y{\t\2\2\2zt\3\2\2\2zw\3\2\2\2{\23\3\2\2\2|}\7\n\2")
        buf.write("\2}~\7\3\2\2~\u0083\7\36\2\2\177\u0080\7\13\2\2\u0080")
        buf.write("\u0081\7\3\2\2\u0081\u0083\7\36\2\2\u0082|\3\2\2\2\u0082")
        buf.write("\177\3\2\2\2\u0083\25\3\2\2\2\u0084\u0085\7\f\2\2\u0085")
        buf.write("\u008a\5\30\r\2\u0086\u0087\7\r\2\2\u0087\u0089\5\30\r")
        buf.write("\2\u0088\u0086\3\2\2\2\u0089\u008c\3\2\2\2\u008a\u0088")
        buf.write("\3\2\2\2\u008a\u008b\3\2\2\2\u008b\u008d\3\2\2\2\u008c")
        buf.write("\u008a\3\2\2\2\u008d\u008e\7\16\2\2\u008e\u0092\3\2\2")
        buf.write("\2\u008f\u0090\7\f\2\2\u0090\u0092\7\16\2\2\u0091\u0084")
        buf.write("\3\2\2\2\u0091\u008f\3\2\2\2\u0092\27\3\2\2\2\u0093\u0096")
        buf.write("\5\62\32\2\u0094\u0096\58\35\2\u0095\u0093\3\2\2\2\u0095")
        buf.write("\u0094\3\2\2\2\u0096\31\3\2\2\2\u0097\u009b\5\34\17\2")
        buf.write("\u0098\u009a\5\34\17\2\u0099\u0098\3\2\2\2\u009a\u009d")
        buf.write("\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c")
        buf.write("\33\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u00a3\5\36\20\2")
        buf.write("\u009f\u00a3\5 \21\2\u00a0\u00a3\5\"\22\2\u00a1\u00a3")
        buf.write("\5$\23\2\u00a2\u009e\3\2\2\2\u00a2\u009f\3\2\2\2\u00a2")
        buf.write("\u00a0\3\2\2\2\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2")
        buf.write("\u00a4\u00a5\7&\2\2\u00a5\35\3\2\2\2\u00a6\u00a7\7\17")
        buf.write("\2\2\u00a7\u00a8\7\3\2\2\u00a8\u00ad\5,\27\2\u00a9\u00aa")
        buf.write("\7\20\2\2\u00aa\u00ab\7\3\2\2\u00ab\u00ad\5,\27\2\u00ac")
        buf.write("\u00a6\3\2\2\2\u00ac\u00a9\3\2\2\2\u00ad\37\3\2\2\2\u00ae")
        buf.write("\u00af\7\21\2\2\u00af\u00b0\7\3\2\2\u00b0\u00b5\5,\27")
        buf.write("\2\u00b1\u00b2\7\22\2\2\u00b2\u00b3\7\3\2\2\u00b3\u00b5")
        buf.write("\5,\27\2\u00b4\u00ae\3\2\2\2\u00b4\u00b1\3\2\2\2\u00b5")
        buf.write("!\3\2\2\2\u00b6\u00b7\7\23\2\2\u00b7\u00b8\7\3\2\2\u00b8")
        buf.write("\u00bd\5,\27\2\u00b9\u00ba\7\24\2\2\u00ba\u00bb\7\3\2")
        buf.write("\2\u00bb\u00bd\5,\27\2\u00bc\u00b6\3\2\2\2\u00bc\u00b9")
        buf.write("\3\2\2\2\u00bd#\3\2\2\2\u00be\u00bf\7\25\2\2\u00bf\u00c0")
        buf.write("\7\3\2\2\u00c0\u00c5\5,\27\2\u00c1\u00c2\7\26\2\2\u00c2")
        buf.write("\u00c3\7\3\2\2\u00c3\u00c5\5,\27\2\u00c4\u00be\3\2\2\2")
        buf.write("\u00c4\u00c1\3\2\2\2\u00c5%\3\2\2\2\u00c6\u00ca\5(\25")
        buf.write("\2\u00c7\u00c9\5(\25\2\u00c8\u00c7\3\2\2\2\u00c9\u00cc")
        buf.write("\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb")
        buf.write("\'\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00ce\7\36\2\2\u00ce")
        buf.write("\u00cf\7\3\2\2\u00cf\u00d0\5*\26\2\u00d0\u00d1\7&\2\2")
        buf.write("\u00d1\u00da\3\2\2\2\u00d2\u00d3\7\36\2\2\u00d3\u00d4")
        buf.write("\7\3\2\2\u00d4\u00d5\7\4\2\2\u00d5\u00d6\5&\24\2\u00d6")
        buf.write("\u00d7\7\5\2\2\u00d7\u00d8\7&\2\2\u00d8\u00da\3\2\2\2")
        buf.write("\u00d9\u00cd\3\2\2\2\u00d9\u00d2\3\2\2\2\u00da)\3\2\2")
        buf.write("\2\u00db\u00e2\7\36\2\2\u00dc\u00e2\7\37\2\2\u00dd\u00e2")
        buf.write("\7\27\2\2\u00de\u00e2\7\30\2\2\u00df\u00e2\7\31\2\2\u00e0")
        buf.write("\u00e2\5\60\31\2\u00e1\u00db\3\2\2\2\u00e1\u00dc\3\2\2")
        buf.write("\2\u00e1\u00dd\3\2\2\2\u00e1\u00de\3\2\2\2\u00e1\u00df")
        buf.write("\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2+\3\2\2\2\u00e3\u00e4")
        buf.write("\7\f\2\2\u00e4\u00e9\5.\30\2\u00e5\u00e6\7\r\2\2\u00e6")
        buf.write("\u00e8\5.\30\2\u00e7\u00e5\3\2\2\2\u00e8\u00eb\3\2\2\2")
        buf.write("\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec\3")
        buf.write("\2\2\2\u00eb\u00e9\3\2\2\2\u00ec\u00ed\7\16\2\2\u00ed")
        buf.write("\u00f1\3\2\2\2\u00ee\u00ef\7\f\2\2\u00ef\u00f1\7\16\2")
        buf.write("\2\u00f0\u00e3\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1-\3\2")
        buf.write("\2\2\u00f2\u00f3\7\36\2\2\u00f3/\3\2\2\2\u00f4\u00f5\7")
        buf.write("\f\2\2\u00f5\u00fa\5*\26\2\u00f6\u00f7\7\r\2\2\u00f7\u00f9")
        buf.write("\5*\26\2\u00f8\u00f6\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa")
        buf.write("\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fd\3\2\2\2")
        buf.write("\u00fc\u00fa\3\2\2\2\u00fd\u00fe\7\16\2\2\u00fe\u0102")
        buf.write("\3\2\2\2\u00ff\u0100\7\f\2\2\u0100\u0102\7\16\2\2\u0101")
        buf.write("\u00f4\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\61\3\2\2\2\u0103")
        buf.write("\u0106\5\64\33\2\u0104\u0106\5\66\34\2\u0105\u0103\3\2")
        buf.write("\2\2\u0105\u0104\3\2\2\2\u0106\63\3\2\2\2\u0107\u0108")
        buf.write("\7$\2\2\u0108\65\3\2\2\2\u0109\u010a\7%\2\2\u010a\67\3")
        buf.write("\2\2\2\u010b\u010c\5:\36\2\u010c\u010d\7\3\2\2\u010d\u010e")
        buf.write("\5:\36\2\u010e\u010f\7\3\2\2\u010f\u0110\5:\36\2\u0110")
        buf.write("\u0111\7\3\2\2\u0111\u0112\5:\36\2\u0112\u0113\7\3\2\2")
        buf.write("\u0113\u0114\5:\36\2\u0114\u0115\7\3\2\2\u0115\u0116\5")
        buf.write(":\36\2\u0116\u0117\7\3\2\2\u0117\u0118\5<\37\2\u0118\u01a8")
        buf.write("\3\2\2\2\u0119\u011a\7\32\2\2\u011a\u011b\5:\36\2\u011b")
        buf.write("\u011c\7\3\2\2\u011c\u011d\5:\36\2\u011d\u011e\7\3\2\2")
        buf.write("\u011e\u011f\5:\36\2\u011f\u0120\7\3\2\2\u0120\u0121\5")
        buf.write(":\36\2\u0121\u0122\7\3\2\2\u0122\u0123\5:\36\2\u0123\u0124")
        buf.write("\7\3\2\2\u0124\u0125\5<\37\2\u0125\u01a8\3\2\2\2\u0126")
        buf.write("\u0128\5:\36\2\u0127\u0126\3\2\2\2\u0127\u0128\3\2\2\2")
        buf.write("\u0128\u0129\3\2\2\2\u0129\u012a\7\32\2\2\u012a\u012b")
        buf.write("\5:\36\2\u012b\u012c\7\3\2\2\u012c\u012d\5:\36\2\u012d")
        buf.write("\u012e\7\3\2\2\u012e\u012f\5:\36\2\u012f\u0130\7\3\2\2")
        buf.write("\u0130\u0131\5:\36\2\u0131\u0132\7\3\2\2\u0132\u0133\5")
        buf.write("<\37\2\u0133\u01a8\3\2\2\2\u0134\u0135\5:\36\2\u0135\u0136")
        buf.write("\7\3\2\2\u0136\u0138\3\2\2\2\u0137\u0134\3\2\2\2\u0137")
        buf.write("\u0138\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\5:\36\2")
        buf.write("\u013a\u0137\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u013c\3")
        buf.write("\2\2\2\u013c\u013d\7\32\2\2\u013d\u013e\5:\36\2\u013e")
        buf.write("\u013f\7\3\2\2\u013f\u0140\5:\36\2\u0140\u0141\7\3\2\2")
        buf.write("\u0141\u0142\5:\36\2\u0142\u0143\7\3\2\2\u0143\u0144\5")
        buf.write("<\37\2\u0144\u01a8\3\2\2\2\u0145\u0146\5:\36\2\u0146\u0147")
        buf.write("\7\3\2\2\u0147\u0149\3\2\2\2\u0148\u0145\3\2\2\2\u0148")
        buf.write("\u0149\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014b\5:\36\2")
        buf.write("\u014b\u014c\7\3\2\2\u014c\u014e\3\2\2\2\u014d\u0148\3")
        buf.write("\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151")
        buf.write("\5:\36\2\u0150\u014d\3\2\2\2\u0150\u0151\3\2\2\2\u0151")
        buf.write("\u0152\3\2\2\2\u0152\u0153\7\32\2\2\u0153\u0154\5:\36")
        buf.write("\2\u0154\u0155\7\3\2\2\u0155\u0156\5:\36\2\u0156\u0157")
        buf.write("\7\3\2\2\u0157\u0158\5<\37\2\u0158\u01a8\3\2\2\2\u0159")
        buf.write("\u015a\5:\36\2\u015a\u015b\7\3\2\2\u015b\u015d\3\2\2\2")
        buf.write("\u015c\u0159\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\3")
        buf.write("\2\2\2\u015e\u015f\5:\36\2\u015f\u0160\7\3\2\2\u0160\u0162")
        buf.write("\3\2\2\2\u0161\u015c\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
        buf.write("\u0163\3\2\2\2\u0163\u0164\5:\36\2\u0164\u0165\7\3\2\2")
        buf.write("\u0165\u0167\3\2\2\2\u0166\u0161\3\2\2\2\u0166\u0167\3")
        buf.write("\2\2\2\u0167\u0168\3\2\2\2\u0168\u016a\5:\36\2\u0169\u0166")
        buf.write("\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b")
        buf.write("\u016c\7\32\2\2\u016c\u016d\5:\36\2\u016d\u016e\7\3\2")
        buf.write("\2\u016e\u016f\5<\37\2\u016f\u01a8\3\2\2\2\u0170\u0171")
        buf.write("\5:\36\2\u0171\u0172\7\3\2\2\u0172\u0174\3\2\2\2\u0173")
        buf.write("\u0170\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2")
        buf.write("\u0175\u0176\5:\36\2\u0176\u0177\7\3\2\2\u0177\u0179\3")
        buf.write("\2\2\2\u0178\u0173\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017a")
        buf.write("\3\2\2\2\u017a\u017b\5:\36\2\u017b\u017c\7\3\2\2\u017c")
        buf.write("\u017e\3\2\2\2\u017d\u0178\3\2\2\2\u017d\u017e\3\2\2\2")
        buf.write("\u017e\u017f\3\2\2\2\u017f\u0180\5:\36\2\u0180\u0181\7")
        buf.write("\3\2\2\u0181\u0183\3\2\2\2\u0182\u017d\3\2\2\2\u0182\u0183")
        buf.write("\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0186\5:\36\2\u0185")
        buf.write("\u0182\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0187\3\2\2\2")
        buf.write("\u0187\u0188\7\32\2\2\u0188\u01a8\5<\37\2\u0189\u018a")
        buf.write("\5:\36\2\u018a\u018b\7\3\2\2\u018b\u018d\3\2\2\2\u018c")
        buf.write("\u0189\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018e\3\2\2\2")
        buf.write("\u018e\u018f\5:\36\2\u018f\u0190\7\3\2\2\u0190\u0192\3")
        buf.write("\2\2\2\u0191\u018c\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193")
        buf.write("\3\2\2\2\u0193\u0194\5:\36\2\u0194\u0195\7\3\2\2\u0195")
        buf.write("\u0197\3\2\2\2\u0196\u0191\3\2\2\2\u0196\u0197\3\2\2\2")
        buf.write("\u0197\u0198\3\2\2\2\u0198\u0199\5:\36\2\u0199\u019a\7")
        buf.write("\3\2\2\u019a\u019c\3\2\2\2\u019b\u0196\3\2\2\2\u019b\u019c")
        buf.write("\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e\5:\36\2\u019e")
        buf.write("\u019f\7\3\2\2\u019f\u01a1\3\2\2\2\u01a0\u019b\3\2\2\2")
        buf.write("\u01a0\u01a1\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a4\5")
        buf.write(":\36\2\u01a3\u01a0\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a5")
        buf.write("\3\2\2\2\u01a5\u01a6\7\32\2\2\u01a6\u01a8\5:\36\2\u01a7")
        buf.write("\u010b\3\2\2\2\u01a7\u0119\3\2\2\2\u01a7\u0127\3\2\2\2")
        buf.write("\u01a7\u013a\3\2\2\2\u01a7\u0150\3\2\2\2\u01a7\u0169\3")
        buf.write("\2\2\2\u01a7\u0185\3\2\2\2\u01a7\u01a3\3\2\2\2\u01a89")
        buf.write("\3\2\2\2\u01a9\u01aa\5> \2\u01aa\u01ab\5> \2\u01ab\u01ac")
        buf.write("\5> \2\u01ac\u01ad\5> \2\u01ad\u01b7\3\2\2\2\u01ae\u01af")
        buf.write("\5> \2\u01af\u01b0\5> \2\u01b0\u01b1\5> \2\u01b1\u01b7")
        buf.write("\3\2\2\2\u01b2\u01b3\5> \2\u01b3\u01b4\5> \2\u01b4\u01b7")
        buf.write("\3\2\2\2\u01b5\u01b7\5> \2\u01b6\u01a9\3\2\2\2\u01b6\u01ae")
        buf.write("\3\2\2\2\u01b6\u01b2\3\2\2\2\u01b6\u01b5\3\2\2\2\u01b7")
        buf.write(";\3\2\2\2\u01b8\u01b9\5:\36\2\u01b9\u01ba\7\3\2\2\u01ba")
        buf.write("\u01bb\5:\36\2\u01bb\u01be\3\2\2\2\u01bc\u01be\5\62\32")
        buf.write("\2\u01bd\u01b8\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be=\3\2")
        buf.write("\2\2\u01bf\u01c0\t\3\2\2\u01c0?\3\2\2\2\62CFbhrz\u0082")
        buf.write("\u008a\u0091\u0095\u009b\u00a2\u00ac\u00b4\u00bc\u00c4")
        buf.write("\u00ca\u00d9\u00e1\u00e9\u00f0\u00fa\u0101\u0105\u0127")
        buf.write("\u0137\u013a\u0148\u014d\u0150\u015c\u0161\u0166\u0169")
        buf.write("\u0173\u0178\u017d\u0182\u0185\u018c\u0191\u0196\u019b")
        buf.write("\u01a0\u01a3\u01a7\u01b6\u01bd")
        return buf.getvalue()


class AspidaParser (Parser):

    grammarFileName = "aspida.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "':'", "'{'", "'}'", "'name'", "'NAME'", 
                     "'connection'", "'CONNECTION'", "'description'", "'DESCRIPTION'", 
                     "'['", "','", "']'", "'sections'", "'SECTIONS'", "'points'", 
                     "'POINTS'", "'controls'", "'CONTROLS'", "'exclusions'", 
                     "'EXCLUSIONS'", "'true'", "'false'", "'null'", "'::'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "';'", "'MAIN'", 
                     "'HOSTS'", "'TASKS'", "'VARS'", "'LOCAL'", "'SSH'", 
                     "'SSH-PASSWORD'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "COMMENT", "WHITESPACE", "NEWLINE", "STRING", 
                      "NUMBER", "DIGIT", "HEX_CHAR", "NUMBER_RANGE", "ARROW", 
                      "SINGLE_IP", "IP_RANGE", "NS", "MAIN_KW", "HOSTS_KW", 
                      "TASKS_KW", "VARS_KW", "LOCAL_KW", "SSH_KW", "SSHPASS_KW" ]

    RULE_program = 0
    RULE_main = 1
    RULE_hosts = 2
    RULE_tasks = 3
    RULE_variables = 4
    RULE_main_content = 5
    RULE_main_prop = 6
    RULE_name = 7
    RULE_connection = 8
    RULE_description = 9
    RULE_hosts_list = 10
    RULE_host = 11
    RULE_tasks_content = 12
    RULE_tasks_prop = 13
    RULE_sections = 14
    RULE_points = 15
    RULE_controls = 16
    RULE_exclusions = 17
    RULE_vars_content = 18
    RULE_vars_prop = 19
    RULE_value = 20
    RULE_str_array = 21
    RULE_cadena = 22
    RULE_array = 23
    RULE_ip_v4 = 24
    RULE_single_ip = 25
    RULE_ip_range = 26
    RULE_ip_v6 = 27
    RULE_h16 = 28
    RULE_ls32 = 29
    RULE_hexdigit = 30

    ruleNames =  [ "program", "main", "hosts", "tasks", "variables", "main_content", 
                   "main_prop", "name", "connection", "description", "hosts_list", 
                   "host", "tasks_content", "tasks_prop", "sections", "points", 
                   "controls", "exclusions", "vars_content", "vars_prop", 
                   "value", "str_array", "cadena", "array", "ip_v4", "single_ip", 
                   "ip_range", "ip_v6", "h16", "ls32", "hexdigit" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    COMMENT=25
    WHITESPACE=26
    NEWLINE=27
    STRING=28
    NUMBER=29
    DIGIT=30
    HEX_CHAR=31
    NUMBER_RANGE=32
    ARROW=33
    SINGLE_IP=34
    IP_RANGE=35
    NS=36
    MAIN_KW=37
    HOSTS_KW=38
    TASKS_KW=39
    VARS_KW=40
    LOCAL_KW=41
    SSH_KW=42
    SSHPASS_KW=43

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

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

        def main(self):
            return self.getTypedRuleContext(AspidaParser.MainContext, 0)


        def hosts(self):
            return self.getTypedRuleContext(AspidaParser.HostsContext, 0)


        def tasks(self):
            return self.getTypedRuleContext(AspidaParser.TasksContext, 0)


        def variables(self):
            return self.getTypedRuleContext(AspidaParser.VariablesContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_program

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

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

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




    def program(self):

        localctx = AspidaParser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 62
            self.main()
            self.state = 63
            self.hosts()
            self.state = 65
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==AspidaParser.TASKS_KW:
                self.state = 64
                self.tasks()


            self.state = 68
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==AspidaParser.VARS_KW:
                self.state = 67
                self.variables()


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


    class MainContext(ParserRuleContext):

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

        def MAIN_KW(self):
            return self.getToken(AspidaParser.MAIN_KW, 0)

        def main_content(self):
            return self.getTypedRuleContext(AspidaParser.Main_contentContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_main

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

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

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




    def main(self):

        localctx = AspidaParser.MainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_main)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 70
            self.match(AspidaParser.MAIN_KW)
            self.state = 71
            self.match(AspidaParser.T__0)
            self.state = 72
            self.match(AspidaParser.T__1)
            self.state = 73
            self.main_content()
            self.state = 74
            self.match(AspidaParser.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 HostsContext(ParserRuleContext):

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

        def HOSTS_KW(self):
            return self.getToken(AspidaParser.HOSTS_KW, 0)

        def hosts_list(self):
            return self.getTypedRuleContext(AspidaParser.Hosts_listContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_hosts

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

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

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




    def hosts(self):

        localctx = AspidaParser.HostsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_hosts)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 76
            self.match(AspidaParser.HOSTS_KW)
            self.state = 77
            self.match(AspidaParser.T__0)
            self.state = 78
            self.hosts_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TasksContext(ParserRuleContext):

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

        def TASKS_KW(self):
            return self.getToken(AspidaParser.TASKS_KW, 0)

        def tasks_content(self):
            return self.getTypedRuleContext(AspidaParser.Tasks_contentContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_tasks

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

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

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




    def tasks(self):

        localctx = AspidaParser.TasksContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_tasks)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 80
            self.match(AspidaParser.TASKS_KW)
            self.state = 81
            self.match(AspidaParser.T__0)
            self.state = 82
            self.match(AspidaParser.T__1)
            self.state = 83
            self.tasks_content()
            self.state = 84
            self.match(AspidaParser.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 VariablesContext(ParserRuleContext):

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

        def VARS_KW(self):
            return self.getToken(AspidaParser.VARS_KW, 0)

        def vars_content(self):
            return self.getTypedRuleContext(AspidaParser.Vars_contentContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_variables

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

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

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




    def variables(self):

        localctx = AspidaParser.VariablesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_variables)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 86
            self.match(AspidaParser.VARS_KW)
            self.state = 87
            self.match(AspidaParser.T__0)
            self.state = 88
            self.match(AspidaParser.T__1)
            self.state = 89
            self.vars_content()
            self.state = 90
            self.match(AspidaParser.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 Main_contentContext(ParserRuleContext):

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

        def main_prop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.Main_propContext)
            else:
                return self.getTypedRuleContext(AspidaParser.Main_propContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_main_content

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

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

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




    def main_content(self):

        localctx = AspidaParser.Main_contentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_main_content)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 92
            self.main_prop()
            self.state = 96
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AspidaParser.T__3) | (1 << AspidaParser.T__4) | (1 << AspidaParser.T__5) | (1 << AspidaParser.T__6) | (1 << AspidaParser.T__7) | (1 << AspidaParser.T__8))) != 0):
                self.state = 93
                self.main_prop()
                self.state = 98
                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 Main_propContext(ParserRuleContext):

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

        def NS(self):
            return self.getToken(AspidaParser.NS, 0)

        def name(self):
            return self.getTypedRuleContext(AspidaParser.NameContext, 0)


        def connection(self):
            return self.getTypedRuleContext(AspidaParser.ConnectionContext, 0)


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


        def getRuleIndex(self):
            return AspidaParser.RULE_main_prop

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

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

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




    def main_prop(self):

        localctx = AspidaParser.Main_propContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_main_prop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 102
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__3, AspidaParser.T__4]:
                self.state = 99
                self.name()
                pass
            elif token in [AspidaParser.T__5, AspidaParser.T__6]:
                self.state = 100
                self.connection()
                pass
            elif token in [AspidaParser.T__7, AspidaParser.T__8]:
                self.state = 101
                self.description()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 104
            self.match(AspidaParser.NS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return AspidaParser.RULE_name

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

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

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




    def name(self):

        localctx = AspidaParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_name)
        try:
            self.state = 112
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__3]:
                self.enterOuterAlt(localctx, 1)
                self.state = 106
                self.match(AspidaParser.T__3)
                self.state = 107
                self.match(AspidaParser.T__0)
                self.state = 108
                self.match(AspidaParser.STRING)
                pass
            elif token in [AspidaParser.T__4]:
                self.enterOuterAlt(localctx, 2)
                self.state = 109
                self.match(AspidaParser.T__4)
                self.state = 110
                self.match(AspidaParser.T__0)
                self.state = 111
                self.match(AspidaParser.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 ConnectionContext(ParserRuleContext):

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

        def LOCAL_KW(self):
            return self.getToken(AspidaParser.LOCAL_KW, 0)

        def SSH_KW(self):
            return self.getToken(AspidaParser.SSH_KW, 0)

        def SSHPASS_KW(self):
            return self.getToken(AspidaParser.SSHPASS_KW, 0)

        def getRuleIndex(self):
            return AspidaParser.RULE_connection

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

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

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




    def connection(self):

        localctx = AspidaParser.ConnectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_connection)
        self._la = 0 # Token type
        try:
            self.state = 120
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 114
                self.match(AspidaParser.T__5)
                self.state = 115
                self.match(AspidaParser.T__0)
                self.state = 116
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AspidaParser.LOCAL_KW) | (1 << AspidaParser.SSH_KW) | (1 << AspidaParser.SSHPASS_KW))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [AspidaParser.T__6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 117
                self.match(AspidaParser.T__6)
                self.state = 118
                self.match(AspidaParser.T__0)
                self.state = 119
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AspidaParser.LOCAL_KW) | (1 << AspidaParser.SSH_KW) | (1 << AspidaParser.SSHPASS_KW))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 DescriptionContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return AspidaParser.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 = AspidaParser.DescriptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_description)
        try:
            self.state = 128
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__7]:
                self.enterOuterAlt(localctx, 1)
                self.state = 122
                self.match(AspidaParser.T__7)
                self.state = 123
                self.match(AspidaParser.T__0)
                self.state = 124
                self.match(AspidaParser.STRING)
                pass
            elif token in [AspidaParser.T__8]:
                self.enterOuterAlt(localctx, 2)
                self.state = 125
                self.match(AspidaParser.T__8)
                self.state = 126
                self.match(AspidaParser.T__0)
                self.state = 127
                self.match(AspidaParser.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 Hosts_listContext(ParserRuleContext):

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

        def host(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.HostContext)
            else:
                return self.getTypedRuleContext(AspidaParser.HostContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_hosts_list

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

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

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




    def hosts_list(self):

        localctx = AspidaParser.Hosts_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_hosts_list)
        self._la = 0 # Token type
        try:
            self.state = 143
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 130
                self.match(AspidaParser.T__9)
                self.state = 131
                self.host()
                self.state = 136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==AspidaParser.T__10:
                    self.state = 132
                    self.match(AspidaParser.T__10)
                    self.state = 133
                    self.host()
                    self.state = 138
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 139
                self.match(AspidaParser.T__11)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 141
                self.match(AspidaParser.T__9)
                self.state = 142
                self.match(AspidaParser.T__11)
                pass


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


    class HostContext(ParserRuleContext):

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

        def ip_v4(self):
            return self.getTypedRuleContext(AspidaParser.Ip_v4Context, 0)


        def ip_v6(self):
            return self.getTypedRuleContext(AspidaParser.Ip_v6Context, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_host

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

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

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




    def host(self):

        localctx = AspidaParser.HostContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_host)
        try:
            self.state = 147
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.SINGLE_IP, AspidaParser.IP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 145
                self.ip_v4()
                pass
            elif token in [AspidaParser.T__23, AspidaParser.DIGIT, AspidaParser.HEX_CHAR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 146
                self.ip_v6()
                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 Tasks_contentContext(ParserRuleContext):

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

        def tasks_prop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.Tasks_propContext)
            else:
                return self.getTypedRuleContext(AspidaParser.Tasks_propContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_tasks_content

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

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

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




    def tasks_content(self):

        localctx = AspidaParser.Tasks_contentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_tasks_content)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 149
            self.tasks_prop()
            self.state = 153
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AspidaParser.T__12) | (1 << AspidaParser.T__13) | (1 << AspidaParser.T__14) | (1 << AspidaParser.T__15) | (1 << AspidaParser.T__16) | (1 << AspidaParser.T__17) | (1 << AspidaParser.T__18) | (1 << AspidaParser.T__19))) != 0):
                self.state = 150
                self.tasks_prop()
                self.state = 155
                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 Tasks_propContext(ParserRuleContext):

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

        def NS(self):
            return self.getToken(AspidaParser.NS, 0)

        def sections(self):
            return self.getTypedRuleContext(AspidaParser.SectionsContext, 0)


        def points(self):
            return self.getTypedRuleContext(AspidaParser.PointsContext, 0)


        def controls(self):
            return self.getTypedRuleContext(AspidaParser.ControlsContext, 0)


        def exclusions(self):
            return self.getTypedRuleContext(AspidaParser.ExclusionsContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_tasks_prop

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

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

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




    def tasks_prop(self):

        localctx = AspidaParser.Tasks_propContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_tasks_prop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 160
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__12, AspidaParser.T__13]:
                self.state = 156
                self.sections()
                pass
            elif token in [AspidaParser.T__14, AspidaParser.T__15]:
                self.state = 157
                self.points()
                pass
            elif token in [AspidaParser.T__16, AspidaParser.T__17]:
                self.state = 158
                self.controls()
                pass
            elif token in [AspidaParser.T__18, AspidaParser.T__19]:
                self.state = 159
                self.exclusions()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 162
            self.match(AspidaParser.NS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SectionsContext(ParserRuleContext):

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

        def str_array(self):
            return self.getTypedRuleContext(AspidaParser.Str_arrayContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_sections

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

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

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




    def sections(self):

        localctx = AspidaParser.SectionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_sections)
        try:
            self.state = 170
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__12]:
                self.enterOuterAlt(localctx, 1)
                self.state = 164
                self.match(AspidaParser.T__12)
                self.state = 165
                self.match(AspidaParser.T__0)
                self.state = 166
                self.str_array()
                pass
            elif token in [AspidaParser.T__13]:
                self.enterOuterAlt(localctx, 2)
                self.state = 167
                self.match(AspidaParser.T__13)
                self.state = 168
                self.match(AspidaParser.T__0)
                self.state = 169
                self.str_array()
                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 PointsContext(ParserRuleContext):

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

        def str_array(self):
            return self.getTypedRuleContext(AspidaParser.Str_arrayContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_points

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

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

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




    def points(self):

        localctx = AspidaParser.PointsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_points)
        try:
            self.state = 178
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__14]:
                self.enterOuterAlt(localctx, 1)
                self.state = 172
                self.match(AspidaParser.T__14)
                self.state = 173
                self.match(AspidaParser.T__0)
                self.state = 174
                self.str_array()
                pass
            elif token in [AspidaParser.T__15]:
                self.enterOuterAlt(localctx, 2)
                self.state = 175
                self.match(AspidaParser.T__15)
                self.state = 176
                self.match(AspidaParser.T__0)
                self.state = 177
                self.str_array()
                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 ControlsContext(ParserRuleContext):

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

        def str_array(self):
            return self.getTypedRuleContext(AspidaParser.Str_arrayContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_controls

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

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

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




    def controls(self):

        localctx = AspidaParser.ControlsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_controls)
        try:
            self.state = 186
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__16]:
                self.enterOuterAlt(localctx, 1)
                self.state = 180
                self.match(AspidaParser.T__16)
                self.state = 181
                self.match(AspidaParser.T__0)
                self.state = 182
                self.str_array()
                pass
            elif token in [AspidaParser.T__17]:
                self.enterOuterAlt(localctx, 2)
                self.state = 183
                self.match(AspidaParser.T__17)
                self.state = 184
                self.match(AspidaParser.T__0)
                self.state = 185
                self.str_array()
                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 ExclusionsContext(ParserRuleContext):

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

        def str_array(self):
            return self.getTypedRuleContext(AspidaParser.Str_arrayContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_exclusions

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

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

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




    def exclusions(self):

        localctx = AspidaParser.ExclusionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_exclusions)
        try:
            self.state = 194
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.T__18]:
                self.enterOuterAlt(localctx, 1)
                self.state = 188
                self.match(AspidaParser.T__18)
                self.state = 189
                self.match(AspidaParser.T__0)
                self.state = 190
                self.str_array()
                pass
            elif token in [AspidaParser.T__19]:
                self.enterOuterAlt(localctx, 2)
                self.state = 191
                self.match(AspidaParser.T__19)
                self.state = 192
                self.match(AspidaParser.T__0)
                self.state = 193
                self.str_array()
                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 Vars_contentContext(ParserRuleContext):

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

        def vars_prop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.Vars_propContext)
            else:
                return self.getTypedRuleContext(AspidaParser.Vars_propContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_vars_content

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

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

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




    def vars_content(self):

        localctx = AspidaParser.Vars_contentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_vars_content)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 196
            self.vars_prop()
            self.state = 200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AspidaParser.STRING:
                self.state = 197
                self.vars_prop()
                self.state = 202
                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 Vars_propContext(ParserRuleContext):

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

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

        def value(self):
            return self.getTypedRuleContext(AspidaParser.ValueContext, 0)


        def NS(self):
            return self.getToken(AspidaParser.NS, 0)

        def vars_content(self):
            return self.getTypedRuleContext(AspidaParser.Vars_contentContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_vars_prop

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

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

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




    def vars_prop(self):

        localctx = AspidaParser.Vars_propContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_vars_prop)
        try:
            self.state = 215
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 203
                self.match(AspidaParser.STRING)
                self.state = 204
                self.match(AspidaParser.T__0)
                self.state = 205
                self.value()
                self.state = 206
                self.match(AspidaParser.NS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 208
                self.match(AspidaParser.STRING)
                self.state = 209
                self.match(AspidaParser.T__0)
                self.state = 210
                self.match(AspidaParser.T__1)
                self.state = 211
                self.vars_content()
                self.state = 212
                self.match(AspidaParser.T__2)
                self.state = 213
                self.match(AspidaParser.NS)
                pass


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


    class ValueContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return AspidaParser.RULE_value

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

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

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




    def value(self):

        localctx = AspidaParser.ValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_value)
        try:
            self.state = 223
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.STRING]:
                self.enterOuterAlt(localctx, 1)
                self.state = 217
                self.match(AspidaParser.STRING)
                pass
            elif token in [AspidaParser.NUMBER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 218
                self.match(AspidaParser.NUMBER)
                pass
            elif token in [AspidaParser.T__20]:
                self.enterOuterAlt(localctx, 3)
                self.state = 219
                self.match(AspidaParser.T__20)
                pass
            elif token in [AspidaParser.T__21]:
                self.enterOuterAlt(localctx, 4)
                self.state = 220
                self.match(AspidaParser.T__21)
                pass
            elif token in [AspidaParser.T__22]:
                self.enterOuterAlt(localctx, 5)
                self.state = 221
                self.match(AspidaParser.T__22)
                pass
            elif token in [AspidaParser.T__9]:
                self.enterOuterAlt(localctx, 6)
                self.state = 222
                self.array()
                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 Str_arrayContext(ParserRuleContext):

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

        def cadena(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.CadenaContext)
            else:
                return self.getTypedRuleContext(AspidaParser.CadenaContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_str_array

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

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

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




    def str_array(self):

        localctx = AspidaParser.Str_arrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_str_array)
        self._la = 0 # Token type
        try:
            self.state = 238
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 225
                self.match(AspidaParser.T__9)
                self.state = 226
                self.cadena()
                self.state = 231
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==AspidaParser.T__10:
                    self.state = 227
                    self.match(AspidaParser.T__10)
                    self.state = 228
                    self.cadena()
                    self.state = 233
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 234
                self.match(AspidaParser.T__11)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 236
                self.match(AspidaParser.T__9)
                self.state = 237
                self.match(AspidaParser.T__11)
                pass


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


    class CadenaContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return AspidaParser.RULE_cadena

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

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

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




    def cadena(self):

        localctx = AspidaParser.CadenaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_cadena)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 240
            self.match(AspidaParser.STRING)
        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 value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.ValueContext)
            else:
                return self.getTypedRuleContext(AspidaParser.ValueContext, i)


        def getRuleIndex(self):
            return AspidaParser.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 = AspidaParser.ArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_array)
        self._la = 0 # Token type
        try:
            self.state = 255
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 242
                self.match(AspidaParser.T__9)
                self.state = 243
                self.value()
                self.state = 248
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==AspidaParser.T__10:
                    self.state = 244
                    self.match(AspidaParser.T__10)
                    self.state = 245
                    self.value()
                    self.state = 250
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 251
                self.match(AspidaParser.T__11)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 253
                self.match(AspidaParser.T__9)
                self.state = 254
                self.match(AspidaParser.T__11)
                pass


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


    class Ip_v4Context(ParserRuleContext):

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

        def single_ip(self):
            return self.getTypedRuleContext(AspidaParser.Single_ipContext, 0)


        def ip_range(self):
            return self.getTypedRuleContext(AspidaParser.Ip_rangeContext, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_ip_v4

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

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

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




    def ip_v4(self):

        localctx = AspidaParser.Ip_v4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_ip_v4)
        try:
            self.state = 259
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.SINGLE_IP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 257
                self.single_ip()
                pass
            elif token in [AspidaParser.IP_RANGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 258
                self.ip_range()
                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 Single_ipContext(ParserRuleContext):

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

        def SINGLE_IP(self):
            return self.getToken(AspidaParser.SINGLE_IP, 0)

        def getRuleIndex(self):
            return AspidaParser.RULE_single_ip

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

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

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




    def single_ip(self):

        localctx = AspidaParser.Single_ipContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_single_ip)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 261
            self.match(AspidaParser.SINGLE_IP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ip_rangeContext(ParserRuleContext):

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

        def IP_RANGE(self):
            return self.getToken(AspidaParser.IP_RANGE, 0)

        def getRuleIndex(self):
            return AspidaParser.RULE_ip_range

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

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

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




    def ip_range(self):

        localctx = AspidaParser.Ip_rangeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_ip_range)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 263
            self.match(AspidaParser.IP_RANGE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ip_v6Context(ParserRuleContext):

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

        def h16(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.H16Context)
            else:
                return self.getTypedRuleContext(AspidaParser.H16Context, i)


        def ls32(self):
            return self.getTypedRuleContext(AspidaParser.Ls32Context, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_ip_v6

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

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

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




    def ip_v6(self):

        localctx = AspidaParser.Ip_v6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_ip_v6)
        self._la = 0 # Token type
        try:
            self.state = 421
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 265
                self.h16()
                self.state = 266
                self.match(AspidaParser.T__0)
                self.state = 267
                self.h16()
                self.state = 268
                self.match(AspidaParser.T__0)
                self.state = 269
                self.h16()
                self.state = 270
                self.match(AspidaParser.T__0)
                self.state = 271
                self.h16()
                self.state = 272
                self.match(AspidaParser.T__0)
                self.state = 273
                self.h16()
                self.state = 274
                self.match(AspidaParser.T__0)
                self.state = 275
                self.h16()
                self.state = 276
                self.match(AspidaParser.T__0)
                self.state = 277
                self.ls32()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 279
                self.match(AspidaParser.T__23)
                self.state = 280
                self.h16()
                self.state = 281
                self.match(AspidaParser.T__0)
                self.state = 282
                self.h16()
                self.state = 283
                self.match(AspidaParser.T__0)
                self.state = 284
                self.h16()
                self.state = 285
                self.match(AspidaParser.T__0)
                self.state = 286
                self.h16()
                self.state = 287
                self.match(AspidaParser.T__0)
                self.state = 288
                self.h16()
                self.state = 289
                self.match(AspidaParser.T__0)
                self.state = 290
                self.ls32()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 292
                    self.h16()


                self.state = 295
                self.match(AspidaParser.T__23)
                self.state = 296
                self.h16()
                self.state = 297
                self.match(AspidaParser.T__0)
                self.state = 298
                self.h16()
                self.state = 299
                self.match(AspidaParser.T__0)
                self.state = 300
                self.h16()
                self.state = 301
                self.match(AspidaParser.T__0)
                self.state = 302
                self.h16()
                self.state = 303
                self.match(AspidaParser.T__0)
                self.state = 304
                self.ls32()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 309
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                    if la_ == 1:
                        self.state = 306
                        self.h16()
                        self.state = 307
                        self.match(AspidaParser.T__0)


                    self.state = 311
                    self.h16()


                self.state = 314
                self.match(AspidaParser.T__23)
                self.state = 315
                self.h16()
                self.state = 316
                self.match(AspidaParser.T__0)
                self.state = 317
                self.h16()
                self.state = 318
                self.match(AspidaParser.T__0)
                self.state = 319
                self.h16()
                self.state = 320
                self.match(AspidaParser.T__0)
                self.state = 321
                self.ls32()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 334
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 331
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
                    if la_ == 1:
                        self.state = 326
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                        if la_ == 1:
                            self.state = 323
                            self.h16()
                            self.state = 324
                            self.match(AspidaParser.T__0)


                        self.state = 328
                        self.h16()
                        self.state = 329
                        self.match(AspidaParser.T__0)


                    self.state = 333
                    self.h16()


                self.state = 336
                self.match(AspidaParser.T__23)
                self.state = 337
                self.h16()
                self.state = 338
                self.match(AspidaParser.T__0)
                self.state = 339
                self.h16()
                self.state = 340
                self.match(AspidaParser.T__0)
                self.state = 341
                self.ls32()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 359
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 356
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
                    if la_ == 1:
                        self.state = 351
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                        if la_ == 1:
                            self.state = 346
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
                            if la_ == 1:
                                self.state = 343
                                self.h16()
                                self.state = 344
                                self.match(AspidaParser.T__0)


                            self.state = 348
                            self.h16()
                            self.state = 349
                            self.match(AspidaParser.T__0)


                        self.state = 353
                        self.h16()
                        self.state = 354
                        self.match(AspidaParser.T__0)


                    self.state = 358
                    self.h16()


                self.state = 361
                self.match(AspidaParser.T__23)
                self.state = 362
                self.h16()
                self.state = 363
                self.match(AspidaParser.T__0)
                self.state = 364
                self.ls32()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 387
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 384
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                    if la_ == 1:
                        self.state = 379
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
                        if la_ == 1:
                            self.state = 374
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                            if la_ == 1:
                                self.state = 369
                                self._errHandler.sync(self)
                                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                                if la_ == 1:
                                    self.state = 366
                                    self.h16()
                                    self.state = 367
                                    self.match(AspidaParser.T__0)


                                self.state = 371
                                self.h16()
                                self.state = 372
                                self.match(AspidaParser.T__0)


                            self.state = 376
                            self.h16()
                            self.state = 377
                            self.match(AspidaParser.T__0)


                        self.state = 381
                        self.h16()
                        self.state = 382
                        self.match(AspidaParser.T__0)


                    self.state = 386
                    self.h16()


                self.state = 389
                self.match(AspidaParser.T__23)
                self.state = 390
                self.ls32()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 417
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AspidaParser.DIGIT or _la==AspidaParser.HEX_CHAR:
                    self.state = 414
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                    if la_ == 1:
                        self.state = 409
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
                        if la_ == 1:
                            self.state = 404
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
                            if la_ == 1:
                                self.state = 399
                                self._errHandler.sync(self)
                                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                                if la_ == 1:
                                    self.state = 394
                                    self._errHandler.sync(self)
                                    la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
                                    if la_ == 1:
                                        self.state = 391
                                        self.h16()
                                        self.state = 392
                                        self.match(AspidaParser.T__0)


                                    self.state = 396
                                    self.h16()
                                    self.state = 397
                                    self.match(AspidaParser.T__0)


                                self.state = 401
                                self.h16()
                                self.state = 402
                                self.match(AspidaParser.T__0)


                            self.state = 406
                            self.h16()
                            self.state = 407
                            self.match(AspidaParser.T__0)


                        self.state = 411
                        self.h16()
                        self.state = 412
                        self.match(AspidaParser.T__0)


                    self.state = 416
                    self.h16()


                self.state = 419
                self.match(AspidaParser.T__23)
                self.state = 420
                self.h16()
                pass


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


    class H16Context(ParserRuleContext):

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

        def hexdigit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.HexdigitContext)
            else:
                return self.getTypedRuleContext(AspidaParser.HexdigitContext, i)


        def getRuleIndex(self):
            return AspidaParser.RULE_h16

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

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

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




    def h16(self):

        localctx = AspidaParser.H16Context(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_h16)
        try:
            self.state = 436
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 423
                self.hexdigit()
                self.state = 424
                self.hexdigit()
                self.state = 425
                self.hexdigit()
                self.state = 426
                self.hexdigit()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 428
                self.hexdigit()
                self.state = 429
                self.hexdigit()
                self.state = 430
                self.hexdigit()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 432
                self.hexdigit()
                self.state = 433
                self.hexdigit()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 435
                self.hexdigit()
                pass


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


    class Ls32Context(ParserRuleContext):

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

        def h16(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AspidaParser.H16Context)
            else:
                return self.getTypedRuleContext(AspidaParser.H16Context, i)


        def ip_v4(self):
            return self.getTypedRuleContext(AspidaParser.Ip_v4Context, 0)


        def getRuleIndex(self):
            return AspidaParser.RULE_ls32

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

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

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




    def ls32(self):

        localctx = AspidaParser.Ls32Context(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_ls32)
        try:
            self.state = 443
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AspidaParser.DIGIT, AspidaParser.HEX_CHAR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 438
                self.h16()
                self.state = 439
                self.match(AspidaParser.T__0)
                self.state = 440
                self.h16()
                pass
            elif token in [AspidaParser.SINGLE_IP, AspidaParser.IP_RANGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 442
                self.ip_v4()
                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 HexdigitContext(ParserRuleContext):

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

        def DIGIT(self):
            return self.getToken(AspidaParser.DIGIT, 0)

        def HEX_CHAR(self):
            return self.getToken(AspidaParser.HEX_CHAR, 0)

        def getRuleIndex(self):
            return AspidaParser.RULE_hexdigit

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

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

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




    def hexdigit(self):

        localctx = AspidaParser.HexdigitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_hexdigit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            _la = self._input.LA(1)
            if not(_la == AspidaParser.DIGIT or _la == AspidaParser.HEX_CHAR):
                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





