# Generated from vhdl.g4 by ANTLR 4.9.3
# 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\u00a4")
        buf.write("\u0a29\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 \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
        buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
        buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
        buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
        buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
        buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
        buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
        buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
        buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
        buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
        buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
        buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
        buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
        buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
        buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
        buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
        buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
        buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
        buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
        buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
        buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
        buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
        buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
        buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
        buf.write("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd")
        buf.write("\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1")
        buf.write("\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4")
        buf.write("\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8")
        buf.write("\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db")
        buf.write("\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df")
        buf.write("\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2")
        buf.write("\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6")
        buf.write("\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9")
        buf.write("\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec\4\u00ed")
        buf.write("\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0")
        buf.write("\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4")
        buf.write("\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7")
        buf.write("\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb")
        buf.write("\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe")
        buf.write("\4\u00ff\t\u00ff\4\u0100\t\u0100\3\2\3\2\3\3\3\3\3\3\3")
        buf.write("\4\3\4\5\4\u0208\n\4\3\4\3\4\5\4\u020c\n\4\3\4\3\4\3\5")
        buf.write("\3\5\5\5\u0212\n\5\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\5\7")
        buf.write("\u021c\n\7\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u0224\n\t\f\t\16")
        buf.write("\t\u0227\13\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u022f\n\n\3")
        buf.write("\n\3\n\3\n\5\n\u0234\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u023b")
        buf.write("\n\13\3\f\3\f\5\f\u023f\n\f\3\r\3\r\3\r\5\r\u0244\n\r")
        buf.write("\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16")
        buf.write("\u0250\n\16\3\16\5\16\u0253\n\16\3\16\3\16\3\17\7\17\u0258")
        buf.write("\n\17\f\17\16\17\u025b\13\17\3\20\3\20\3\20\5\20\u0260")
        buf.write("\n\20\3\20\3\20\5\20\u0264\n\20\3\20\3\20\5\20\u0268\n")
        buf.write("\20\3\20\5\20\u026b\n\20\3\20\3\20\3\20\3\20\3\20\5\20")
        buf.write("\u0272\n\20\3\21\7\21\u0275\n\21\f\21\16\21\u0278\13\21")
        buf.write("\3\22\3\22\5\22\u027c\n\22\3\23\3\23\5\23\u0280\n\23\3")
        buf.write("\24\3\24\3\24\3\24\5\24\u0286\n\24\3\24\3\24\5\24\u028a")
        buf.write("\n\24\3\25\5\25\u028d\n\25\3\25\3\25\3\25\3\26\3\26\3")
        buf.write("\26\5\26\u0295\n\26\3\26\3\26\3\27\3\27\3\27\7\27\u029c")
        buf.write("\n\27\f\27\16\27\u029f\13\27\3\30\3\30\3\30\3\30\3\30")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u02ad\n\31\3")
        buf.write("\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33")
        buf.write("\3\34\3\34\5\34\u02bc\n\34\3\34\5\34\u02bf\n\34\3\34\5")
        buf.write("\34\u02c2\n\34\3\35\3\35\3\35\7\35\u02c7\n\35\f\35\16")
        buf.write("\35\u02ca\13\35\3\35\7\35\u02cd\n\35\f\35\16\35\u02d0")
        buf.write("\13\35\3\35\3\35\3\35\3\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\3\36\3\36\3\36")
        buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u02ec\n\36\3\37\7")
        buf.write("\37\u02ef\n\37\f\37\16\37\u02f2\13\37\3 \3 \3 \3 \5 \u02f8")
        buf.write("\n \5 \u02fa\n \3 \3 \3 \3 \5 \u0300\n \5 \u0302\n \3")
        buf.write("!\3!\3!\3!\3!\5!\u0309\n!\3!\5!\u030c\n!\3\"\3\"\3\"\3")
        buf.write("\"\3\"\3\"\5\"\u0314\n\"\3\"\5\"\u0317\n\"\3\"\3\"\3\"")
        buf.write("\3\"\3\"\3\"\3\"\5\"\u0320\n\"\3\"\3\"\3#\7#\u0325\n#")
        buf.write("\f#\16#\u0328\13#\3$\3$\5$\u032c\n$\3$\5$\u032f\n$\3$")
        buf.write("\3$\3$\3%\5%\u0335\n%\3%\3%\3%\3%\3&\3&\3&\7&\u033e\n")
        buf.write("&\f&\16&\u0341\13&\3\'\3\'\3\'\3\'\3(\5(\u0348\n(\3(\3")
        buf.write("(\5(\u034c\n(\3(\3(\5(\u0350\n(\3(\3(\3)\5)\u0355\n)\3")
        buf.write(")\3)\3)\3)\6)\u035b\n)\r)\16)\u035c\3)\3)\3)\5)\u0362")
        buf.write("\n)\3)\3)\3*\3*\3*\3*\3*\3+\3+\3+\3+\5+\u036f\n+\3,\3")
        buf.write(",\3,\7,\u0374\n,\f,\16,\u0377\13,\3-\3-\3-\3-\3-\5-\u037e")
        buf.write("\n-\3-\5-\u0381\n-\3-\3-\3-\3-\3.\3.\3.\5.\u038a\n.\3")
        buf.write(".\5.\u038d\n.\3.\5.\u0390\n.\3.\3.\3.\5.\u0395\n.\3.\3")
        buf.write(".\3/\3/\3/\5/\u039c\n/\3/\5/\u039f\n/\3/\3/\3\60\3\60")
        buf.write("\3\60\3\60\3\61\3\61\5\61\u03a9\n\61\3\62\3\62\5\62\u03ad")
        buf.write("\n\62\3\63\5\63\u03b0\n\63\3\63\5\63\u03b3\n\63\3\63\3")
        buf.write("\63\3\63\3\64\5\64\u03b9\n\64\3\64\3\64\5\64\u03bd\n\64")
        buf.write("\3\64\5\64\u03c0\n\64\3\64\3\64\5\64\u03c4\n\64\3\64\3")
        buf.write("\64\3\65\5\65\u03c9\n\65\3\65\5\65\u03cc\n\65\3\65\3\65")
        buf.write("\3\65\3\66\5\66\u03d2\n\66\3\66\5\66\u03d5\n\66\3\66\3")
        buf.write("\66\5\66\u03d9\n\66\3\67\3\67\38\38\38\39\39\39\39\39")
        buf.write("\39\3:\3:\3:\3:\3:\5:\u03eb\n:\5:\u03ed\n:\3;\3;\3;\3")
        buf.write(";\3;\3;\3;\3;\3;\5;\u03f8\n;\3;\5;\u03fb\n;\3;\3;\3<\3")
        buf.write("<\3<\5<\u0402\n<\3=\7=\u0405\n=\f=\16=\u0408\13=\3>\3")
        buf.write(">\5>\u040c\n>\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3@\5@\u0419")
        buf.write("\n@\3@\3@\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\5C\u0429")
        buf.write("\nC\3D\7D\u042c\nD\fD\16D\u042f\13D\3E\3E\5E\u0433\nE")
        buf.write("\3F\3F\3F\5F\u0438\nF\3F\5F\u043b\nF\3G\7G\u043e\nG\f")
        buf.write("G\16G\u0441\13G\3G\3G\3H\3H\3H\3I\3I\5I\u044a\nI\3J\3")
        buf.write("J\3K\3K\3K\3K\3K\3K\3L\3L\5L\u0456\nL\3M\3M\3M\5M\u045b")
        buf.write("\nM\3M\3M\3N\3N\3N\3N\3N\3O\3O\3P\3P\3Q\3Q\3Q\3Q\3Q\3")
        buf.write("Q\5Q\u046e\nQ\3Q\3Q\3Q\5Q\u0473\nQ\3R\3R\3S\3S\5S\u0479")
        buf.write("\nS\3T\3T\3T\7T\u047e\nT\fT\16T\u0481\13T\3U\3U\3U\3U")
        buf.write("\3U\3U\3U\5U\u048a\nU\3U\3U\5U\u048e\nU\3U\5U\u0491\n")
        buf.write("U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3")
        buf.write("V\3V\3V\3V\3V\5V\u04a9\nV\3W\7W\u04ac\nW\fW\16W\u04af")
        buf.write("\13W\3X\3X\5X\u04b3\nX\3Y\5Y\u04b6\nY\3Y\5Y\u04b9\nY\3")
        buf.write("Z\3Z\3Z\7Z\u04be\nZ\fZ\16Z\u04c1\13Z\3Z\3Z\5Z\u04c5\n")
        buf.write("Z\3[\3[\3[\3[\3\\\3\\\3\\\5\\\u04ce\n\\\3]\7]\u04d1\n")
        buf.write("]\f]\16]\u04d4\13]\3^\3^\3^\5^\u04d9\n^\3_\3_\5_\u04dd")
        buf.write("\n_\3`\3`\3`\3`\7`\u04e3\n`\f`\16`\u04e6\13`\3`\3`\3a")
        buf.write("\5a\u04eb\na\3a\3a\5a\u04ef\na\3a\3a\5a\u04f3\na\3a\3")
        buf.write("a\3b\3b\3b\3b\7b\u04fb\nb\fb\16b\u04fe\13b\3c\3c\3c\5")
        buf.write("c\u0503\nc\3c\3c\3c\3c\5c\u0509\nc\3d\3d\3d\3d\3d\5d\u0510")
        buf.write("\nd\3d\3d\3e\3e\3f\3f\5f\u0518\nf\3f\3f\3f\3g\3g\3g\3")
        buf.write("g\3h\3h\3i\3i\3i\3i\3i\3i\5i\u0529\ni\3j\3j\3j\3j\3j\3")
        buf.write("j\5j\u0531\nj\3j\3j\3k\3k\3k\3k\7k\u0539\nk\fk\16k\u053c")
        buf.write("\13k\3k\5k\u053f\nk\3k\7k\u0542\nk\fk\16k\u0545\13k\3")
        buf.write("k\3k\3k\5k\u054a\nk\3k\3k\3l\3l\3l\3l\5l\u0552\nl\3m\3")
        buf.write("m\3m\3m\3m\3m\3n\3n\3n\7n\u055d\nn\fn\16n\u0560\13n\3")
        buf.write("o\3o\3o\3o\3o\3o\3p\3p\5p\u056a\np\3q\3q\3q\7q\u056f\n")
        buf.write("q\fq\16q\u0572\13q\3r\3r\3r\3r\3r\3r\3r\3r\3s\3s\3s\3")
        buf.write("s\3s\3s\3s\3s\3t\3t\3t\3t\3u\3u\3v\3v\3v\7v\u058d\nv\f")
        buf.write("v\16v\u0590\13v\3w\5w\u0593\nw\3w\3w\3w\3w\3w\3w\3w\3")
        buf.write("w\3w\7w\u059e\nw\fw\16w\u05a1\13w\3w\3w\5w\u05a5\nw\3")
        buf.write("w\3w\3w\5w\u05aa\nw\3w\3w\3x\3x\3x\3x\7x\u05b2\nx\fx\16")
        buf.write("x\u05b5\13x\3x\3x\3y\3y\5y\u05bb\ny\3z\3z\3z\3z\3{\5{")
        buf.write("\u05c2\n{\3{\3{\3{\3{\3{\3{\3{\5{\u05cb\n{\3{\3{\5{\u05cf")
        buf.write("\n{\3|\3|\3|\7|\u05d4\n|\f|\16|\u05d7\13|\3|\3|\5|\u05db")
        buf.write("\n|\3}\5}\u05de\n}\3}\3}\3}\5}\u05e3\n}\3}\3}\3}\5}\u05e8")
        buf.write("\n}\3~\3~\3~\3~\3~\3~\5~\u05f0\n~\3\177\3\177\3\u0080")
        buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081")
        buf.write("\7\u0081\u05fc\n\u0081\f\u0081\16\u0081\u05ff\13\u0081")
        buf.write("\3\u0082\3\u0082\3\u0082\7\u0082\u0604\n\u0082\f\u0082")
        buf.write("\16\u0082\u0607\13\u0082\3\u0083\3\u0083\3\u0083\7\u0083")
        buf.write("\u060c\n\u0083\f\u0083\16\u0083\u060f\13\u0083\3\u0084")
        buf.write("\3\u0084\3\u0084\3\u0084\5\u0084\u0615\n\u0084\3\u0084")
        buf.write("\3\u0084\3\u0084\5\u0084\u061a\n\u0084\3\u0085\3\u0085")
        buf.write("\3\u0085\5\u0085\u061f\n\u0085\3\u0085\3\u0085\5\u0085")
        buf.write("\u0623\n\u0085\3\u0085\3\u0085\5\u0085\u0627\n\u0085\3")
        buf.write("\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u062d\n\u0086\3")
        buf.write("\u0086\3\u0086\5\u0086\u0631\n\u0086\3\u0086\3\u0086\5")
        buf.write("\u0086\u0635\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3")
        buf.write("\u0087\3\u0088\5\u0088\u063d\n\u0088\3\u0088\3\u0088\3")
        buf.write("\u0088\5\u0088\u0642\n\u0088\3\u0088\3\u0088\3\u0088\5")
        buf.write("\u0088\u0647\n\u0088\3\u0089\3\u0089\3\u0089\3\u0089\5")
        buf.write("\u0089\u064d\n\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3")
        buf.write("\u008b\3\u008b\3\u008b\3\u008c\3\u008c\5\u008c\u0658\n")
        buf.write("\u008c\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\5\u008d")
        buf.write("\u065f\n\u008d\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f")
        buf.write("\7\u008f\u0666\n\u008f\f\u008f\16\u008f\u0669\13\u008f")
        buf.write("\3\u0090\3\u0090\3\u0091\5\u0091\u066e\n\u0091\3\u0091")
        buf.write("\5\u0091\u0671\n\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
        buf.write("\3\u0091\5\u0091\u0678\n\u0091\3\u0091\3\u0091\3\u0092")
        buf.write("\3\u0092\3\u0093\3\u0093\3\u0094\3\u0094\5\u0094\u0682")
        buf.write("\n\u0094\3\u0094\7\u0094\u0685\n\u0094\f\u0094\16\u0094")
        buf.write("\u0688\13\u0094\3\u0095\3\u0095\3\u0095\3\u0095\5\u0095")
        buf.write("\u068e\n\u0095\3\u0096\3\u0096\3\u0096\7\u0096\u0693\n")
        buf.write("\u0096\f\u0096\16\u0096\u0696\13\u0096\3\u0097\3\u0097")
        buf.write("\6\u0097\u069a\n\u0097\r\u0097\16\u0097\u069b\3\u0098")
        buf.write("\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099")
        buf.write("\3\u009a\5\u009a\u06a7\n\u009a\3\u009a\3\u009a\3\u009a")
        buf.write("\3\u009a\3\u009a\3\u009a\5\u009a\u06af\n\u009a\3\u009b")
        buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c")
        buf.write("\5\u009c\u06b9\n\u009c\3\u009d\3\u009d\3\u009d\3\u009d")
        buf.write("\3\u009e\5\u009e\u06c0\n\u009e\3\u009e\3\u009e\5\u009e")
        buf.write("\u06c4\n\u009e\3\u009e\3\u009e\5\u009e\u06c8\n\u009e\3")
        buf.write("\u009e\3\u009e\3\u009f\3\u009f\5\u009f\u06ce\n\u009f\3")
        buf.write("\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0")
        buf.write("\u06d6\n\u00a0\3\u00a1\5\u00a1\u06d9\n\u00a1\3\u00a1\5")
        buf.write("\u00a1\u06dc\n\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3")
        buf.write("\u00a2\3\u00a2\3\u00a2\3\u00a2\5\u00a2\u06e6\n\u00a2\3")
        buf.write("\u00a2\5\u00a2\u06e9\n\u00a2\3\u00a2\3\u00a2\3\u00a3\3")
        buf.write("\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3")
        buf.write("\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u06f8\n\u00a3\3\u00a4")
        buf.write("\7\u00a4\u06fb\n\u00a4\f\u00a4\16\u00a4\u06fe\13\u00a4")
        buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\5\u00a5")
        buf.write("\u0706\n\u00a5\3\u00a5\5\u00a5\u0709\n\u00a5\3\u00a5\3")
        buf.write("\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
        buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
        buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\5\u00a6")
        buf.write("\u0720\n\u00a6\3\u00a7\7\u00a7\u0723\n\u00a7\f\u00a7\16")
        buf.write("\u00a7\u0726\13\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
        buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
        buf.write("\7\u00aa\u0733\n\u00aa\f\u00aa\16\u00aa\u0736\13\u00aa")
        buf.write("\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u073b\n\u00aa\3\u00ab")
        buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac")
        buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
        buf.write("\3\u00ae\5\u00ae\u0754\n\u00ae\3\u00af\3\u00af\3\u00af")
        buf.write("\5\u00af\u0759\n\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
        buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
        buf.write("\3\u00b0\5\u00b0\u0767\n\u00b0\3\u00b1\7\u00b1\u076a\n")
        buf.write("\u00b1\f\u00b1\16\u00b1\u076d\13\u00b1\3\u00b2\7\u00b2")
        buf.write("\u0770\n\u00b2\f\u00b2\16\u00b2\u0773\13\u00b2\3\u00b3")
        buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u077a\n\u00b3")
        buf.write("\3\u00b4\5\u00b4\u077d\n\u00b4\3\u00b4\3\u00b4\3\u00b4")
        buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
        buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\5\u00b5")
        buf.write("\u078f\n\u00b5\3\u00b6\7\u00b6\u0792\n\u00b6\f\u00b6\16")
        buf.write("\u00b6\u0795\13\u00b6\3\u00b7\5\u00b7\u0798\n\u00b7\3")
        buf.write("\u00b7\5\u00b7\u079b\n\u00b7\3\u00b7\3\u00b7\3\u00b7\3")
        buf.write("\u00b7\3\u00b7\5\u00b7\u07a2\n\u00b7\3\u00b7\5\u00b7\u07a5")
        buf.write("\n\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\5\u00b7")
        buf.write("\u07ac\n\u00b7\3\u00b7\3\u00b7\5\u00b7\u07b0\n\u00b7\3")
        buf.write("\u00b7\3\u00b7\3\u00b8\7\u00b8\u07b5\n\u00b8\f\u00b8\16")
        buf.write("\u00b8\u07b8\13\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
        buf.write("\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07c1\n\u00b9\3\u00ba")
        buf.write("\3\u00ba\3\u00ba\5\u00ba\u07c6\n\u00ba\3\u00bb\3\u00bb")
        buf.write("\3\u00bb\7\u00bb\u07cb\n\u00bb\f\u00bb\16\u00bb\u07ce")
        buf.write("\13\u00bb\3\u00bb\3\u00bb\5\u00bb\u07d2\n\u00bb\3\u00bc")
        buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd\5\u00bd\u07da")
        buf.write("\n\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\5\u00be\u07e0")
        buf.write("\n\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\6\u00c0")
        buf.write("\u07e7\n\u00c0\r\u00c0\16\u00c0\u07e8\3\u00c0\3\u00c0")
        buf.write("\3\u00c0\5\u00c0\u07ee\n\u00c0\3\u00c1\3\u00c1\6\u00c1")
        buf.write("\u07f2\n\u00c1\r\u00c1\16\u00c1\u07f3\3\u00c1\3\u00c1")
        buf.write("\3\u00c1\5\u00c1\u07f9\n\u00c1\3\u00c2\3\u00c2\3\u00c2")
        buf.write("\3\u00c2\5\u00c2\u07ff\n\u00c2\3\u00c3\3\u00c3\3\u00c4")
        buf.write("\5\u00c4\u0804\n\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
        buf.write("\5\u00c4\u080a\n\u00c4\3\u00c4\3\u00c4\3\u00c5\5\u00c5")
        buf.write("\u080f\n\u00c5\3\u00c5\3\u00c5\5\u00c5\u0813\n\u00c5\3")
        buf.write("\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6")
        buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\5\u00c7\u0821")
        buf.write("\n\u00c7\3\u00c8\3\u00c8\5\u00c8\u0825\n\u00c8\3\u00c9")
        buf.write("\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca")
        buf.write("\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00cb")
        buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
        buf.write("\7\u00cb\u083d\n\u00cb\f\u00cb\16\u00cb\u0840\13\u00cb")
        buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd\3\u00cd\7\u00cd")
        buf.write("\u0848\n\u00cd\f\u00cd\16\u00cd\u084b\13\u00cd\3\u00ce")
        buf.write("\7\u00ce\u084e\n\u00ce\f\u00ce\16\u00ce\u0851\13\u00ce")
        buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf")
        buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\5\u00cf\u085f")
        buf.write("\n\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\5\u00cf\u0865")
        buf.write("\n\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u086b")
        buf.write("\n\u00d0\3\u00d1\3\u00d1\3\u00d2\5\u00d2\u0870\n\u00d2")
        buf.write("\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0875\n\u00d2\3\u00d2")
        buf.write("\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
        buf.write("\5\u00d3\u087f\n\u00d3\3\u00d3\3\u00d3\5\u00d3\u0883\n")
        buf.write("\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d5\3\u00d5")
        buf.write("\3\u00d5\7\u00d5\u088c\n\u00d5\f\u00d5\16\u00d5\u088f")
        buf.write("\13\u00d5\3\u00d5\3\u00d5\5\u00d5\u0893\n\u00d5\3\u00d6")
        buf.write("\3\u00d6\3\u00d6\3\u00d6\7\u00d6\u0899\n\u00d6\f\u00d6")
        buf.write("\16\u00d6\u089c\13\u00d6\5\u00d6\u089e\n\u00d6\3\u00d6")
        buf.write("\3\u00d6\5\u00d6\u08a2\n\u00d6\3\u00d6\3\u00d6\3\u00d7")
        buf.write("\5\u00d7\u08a7\n\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7")
        buf.write("\7\u00d7\u08ad\n\u00d7\f\u00d7\16\u00d7\u08b0\13\u00d7")
        buf.write("\3\u00d8\5\u00d8\u08b3\n\u00d8\3\u00d8\3\u00d8\3\u00d8")
        buf.write("\3\u00d8\5\u00d8\u08b9\n\u00d8\3\u00d8\3\u00d8\3\u00d9")
        buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\5\u00da\u08c3")
        buf.write("\n\u00da\3\u00da\3\u00da\3\u00da\3\u00da\6\u00da\u08c9")
        buf.write("\n\u00da\r\u00da\16\u00da\u08ca\3\u00da\3\u00da\3\u00da")
        buf.write("\5\u00da\u08d0\n\u00da\3\u00da\3\u00da\3\u00db\5\u00db")
        buf.write("\u08d5\n\u00db\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db")
        buf.write("\3\u00db\3\u00db\3\u00db\3\u00db\7\u00db\u08e0\n\u00db")
        buf.write("\f\u00db\16\u00db\u08e3\13\u00db\3\u00db\3\u00db\5\u00db")
        buf.write("\u08e7\n\u00db\3\u00db\3\u00db\3\u00db\5\u00db\u08ec\n")
        buf.write("\u00db\3\u00db\3\u00db\3\u00dc\5\u00dc\u08f1\n\u00dc\3")
        buf.write("\u00dc\3\u00dc\5\u00dc\u08f5\n\u00dc\3\u00dc\3\u00dc\3")
        buf.write("\u00dc\3\u00dc\3\u00dc\3\u00dc\5\u00dc\u08fd\n\u00dc\3")
        buf.write("\u00dc\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd")
        buf.write("\5\u00dd\u0906\n\u00dd\3\u00dd\3\u00dd\5\u00dd\u090a\n")
        buf.write("\u00dd\3\u00de\7\u00de\u090d\n\u00de\f\u00de\16\u00de")
        buf.write("\u0910\13\u00de\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df")
        buf.write("\3\u00df\3\u00df\5\u00df\u0919\n\u00df\3\u00e0\3\u00e0")
        buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1")
        buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2\3\u00e2\3\u00e2")
        buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e3\3\u00e3\5\u00e3\u0930")
        buf.write("\n\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
        buf.write("\5\u00e3\u0938\n\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4")
        buf.write("\3\u00e4\3\u00e4\3\u00e4\5\u00e4\u0941\n\u00e4\3\u00e4")
        buf.write("\5\u00e4\u0944\n\u00e4\3\u00e4\3\u00e4\3\u00e5\3\u00e5")
        buf.write("\3\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
        buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
        buf.write("\5\u00e6\u0958\n\u00e6\3\u00e7\7\u00e7\u095b\n\u00e7\f")
        buf.write("\u00e7\16\u00e7\u095e\13\u00e7\3\u00e8\3\u00e8\3\u00e9")
        buf.write("\3\u00e9\5\u00e9\u0964\n\u00e9\3\u00ea\3\u00ea\3\u00ea")
        buf.write("\3\u00ea\3\u00ea\3\u00ea\5\u00ea\u096c\n\u00ea\3\u00eb")
        buf.write("\5\u00eb\u096f\n\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb")
        buf.write("\3\u00eb\3\u00eb\5\u00eb\u0977\n\u00eb\3\u00eb\3\u00eb")
        buf.write("\3\u00eb\3\u00ec\7\u00ec\u097d\n\u00ec\f\u00ec\16\u00ec")
        buf.write("\u0980\13\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
        buf.write("\3\u00ed\3\u00ee\3\u00ee\5\u00ee\u098a\n\u00ee\3\u00ee")
        buf.write("\5\u00ee\u098d\n\u00ee\3\u00ee\5\u00ee\u0990\n\u00ee\3")
        buf.write("\u00ef\3\u00ef\3\u00ef\3\u00ef\5\u00ef\u0996\n\u00ef\3")
        buf.write("\u00f0\3\u00f0\5\u00f0\u099a\n\u00f0\3\u00f1\3\u00f1\3")
        buf.write("\u00f1\3\u00f1\7\u00f1\u09a0\n\u00f1\f\u00f1\16\u00f1")
        buf.write("\u09a3\13\u00f1\3\u00f2\3\u00f2\3\u00f2\5\u00f2\u09a8")
        buf.write("\n\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
        buf.write("\3\u00f4\3\u00f4\5\u00f4\u09b2\n\u00f4\3\u00f4\3\u00f4")
        buf.write("\5\u00f4\u09b6\n\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5")
        buf.write("\3\u00f5\3\u00f6\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7")
        buf.write("\3\u00f7\5\u00f7\u09c4\n\u00f7\3\u00f7\3\u00f7\3\u00f8")
        buf.write("\3\u00f8\3\u00f8\3\u00f8\5\u00f8\u09cc\n\u00f8\3\u00f9")
        buf.write("\3\u00f9\3\u00f9\3\u00f9\3\u00f9\7\u00f9\u09d3\n\u00f9")
        buf.write("\f\u00f9\16\u00f9\u09d6\13\u00f9\3\u00f9\3\u00f9\3\u00f9")
        buf.write("\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\7\u00fa")
        buf.write("\u09e1\n\u00fa\f\u00fa\16\u00fa\u09e4\13\u00fa\3\u00fa")
        buf.write("\3\u00fa\3\u00fa\3\u00fa\3\u00fb\3\u00fb\3\u00fb\3\u00fb")
        buf.write("\7\u00fb\u09ee\n\u00fb\f\u00fb\16\u00fb\u09f1\13\u00fb")
        buf.write("\3\u00fb\3\u00fb\3\u00fc\5\u00fc\u09f6\n\u00fc\3\u00fc")
        buf.write("\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fd\5\u00fd\u09fe")
        buf.write("\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd")
        buf.write("\5\u00fd\u0a06\n\u00fd\3\u00fd\3\u00fd\3\u00fe\5\u00fe")
        buf.write("\u0a0b\n\u00fe\3\u00fe\3\u00fe\5\u00fe\u0a0f\n\u00fe\3")
        buf.write("\u00fe\5\u00fe\u0a12\n\u00fe\3\u00fe\5\u00fe\u0a15\n\u00fe")
        buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\3\u00ff\7\u00ff\u0a1c")
        buf.write("\n\u00ff\f\u00ff\16\u00ff\u0a1f\13\u00ff\3\u00ff\5\u00ff")
        buf.write("\u0a22\n\u00ff\3\u0100\3\u0100\3\u0100\5\u0100\u0a27\n")
        buf.write("\u0100\3\u0100\2\2\u0101\2\4\6\b\n\f\16\20\22\24\26\30")
        buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b")
        buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
        buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
        buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0")
        buf.write("\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2")
        buf.write("\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4")
        buf.write("\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6")
        buf.write("\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8")
        buf.write("\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a")
        buf.write("\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c")
        buf.write("\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e")
        buf.write("\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140")
        buf.write("\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152")
        buf.write("\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164")
        buf.write("\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176")
        buf.write("\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188")
        buf.write("\u018a\u018c\u018e\u0190\u0192\u0194\u0196\u0198\u019a")
        buf.write("\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac")
        buf.write("\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be")
        buf.write("\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0")
        buf.write("\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u01e0\u01e2")
        buf.write("\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4")
        buf.write("\u01f6\u01f8\u01fa\u01fc\u01fe\2\21\5\2rrww\u00a0\u00a0")
        buf.write("\4\2\u008e\u008e\u0096\u0097\4\2\31\31cc\23\2\n\n\25\27")
        buf.write("\33\33\37\37!!$$,,\60\60\65\65BBFFIIXX^`ffhhkk\3\2xy\4")
        buf.write("\2((AA\7\2\t\t\64\6499??pq\7\2\22\22((**//AA\5\2\63\63")
        buf.write("MM\u0094\u0095\5\2\u0085\u0086\u0088\u0088\u0098\u009a")
        buf.write("\5\2STYZ\\]\4\2\23\23PP\3\2\u0096\u0097\4\2!!FF\4\2\'")
        buf.write("\'HH\2\u0aef\2\u0200\3\2\2\2\4\u0202\3\2\2\2\6\u0205\3")
        buf.write("\2\2\2\b\u0211\3\2\2\2\n\u0213\3\2\2\2\f\u021b\3\2\2\2")
        buf.write("\16\u021d\3\2\2\2\20\u021f\3\2\2\2\22\u022a\3\2\2\2\24")
        buf.write("\u023a\3\2\2\2\26\u023e\3\2\2\2\30\u0240\3\2\2\2\32\u0245")
        buf.write("\3\2\2\2\34\u0259\3\2\2\2\36\u0271\3\2\2\2 \u0276\3\2")
        buf.write("\2\2\"\u027b\3\2\2\2$\u027f\3\2\2\2&\u0281\3\2\2\2(\u028c")
        buf.write("\3\2\2\2*\u0294\3\2\2\2,\u0298\3\2\2\2.\u02a0\3\2\2\2")
        buf.write("\60\u02ac\3\2\2\2\62\u02ae\3\2\2\2\64\u02b6\3\2\2\2\66")
        buf.write("\u02bb\3\2\2\28\u02c3\3\2\2\2:\u02eb\3\2\2\2<\u02f0\3")
        buf.write("\2\2\2>\u02f9\3\2\2\2@\u030b\3\2\2\2B\u030d\3\2\2\2D\u0326")
        buf.write("\3\2\2\2F\u0329\3\2\2\2H\u0334\3\2\2\2J\u033a\3\2\2\2")
        buf.write("L\u0342\3\2\2\2N\u0347\3\2\2\2P\u0354\3\2\2\2R\u0365\3")
        buf.write("\2\2\2T\u036e\3\2\2\2V\u0370\3\2\2\2X\u0378\3\2\2\2Z\u0386")
        buf.write("\3\2\2\2\\\u0398\3\2\2\2^\u03a2\3\2\2\2`\u03a8\3\2\2\2")
        buf.write("b\u03ac\3\2\2\2d\u03af\3\2\2\2f\u03b8\3\2\2\2h\u03c8\3")
        buf.write("\2\2\2j\u03d1\3\2\2\2l\u03da\3\2\2\2n\u03dc\3\2\2\2p\u03df")
        buf.write("\3\2\2\2r\u03e5\3\2\2\2t\u03ee\3\2\2\2v\u0401\3\2\2\2")
        buf.write("x\u0406\3\2\2\2z\u040b\3\2\2\2|\u040d\3\2\2\2~\u0412\3")
        buf.write("\2\2\2\u0080\u041c\3\2\2\2\u0082\u0421\3\2\2\2\u0084\u0428")
        buf.write("\3\2\2\2\u0086\u042d\3\2\2\2\u0088\u0432\3\2\2\2\u008a")
        buf.write("\u043a\3\2\2\2\u008c\u043f\3\2\2\2\u008e\u0444\3\2\2\2")
        buf.write("\u0090\u0449\3\2\2\2\u0092\u044b\3\2\2\2\u0094\u044d\3")
        buf.write("\2\2\2\u0096\u0455\3\2\2\2\u0098\u045a\3\2\2\2\u009a\u045e")
        buf.write("\3\2\2\2\u009c\u0463\3\2\2\2\u009e\u0465\3\2\2\2\u00a0")
        buf.write("\u0472\3\2\2\2\u00a2\u0474\3\2\2\2\u00a4\u0476\3\2\2\2")
        buf.write("\u00a6\u047a\3\2\2\2\u00a8\u0482\3\2\2\2\u00aa\u04a8\3")
        buf.write("\2\2\2\u00ac\u04ad\3\2\2\2\u00ae\u04b0\3\2\2\2\u00b0\u04b5")
        buf.write("\3\2\2\2\u00b2\u04c4\3\2\2\2\u00b4\u04c6\3\2\2\2\u00b6")
        buf.write("\u04cd\3\2\2\2\u00b8\u04d2\3\2\2\2\u00ba\u04d8\3\2\2\2")
        buf.write("\u00bc\u04dc\3\2\2\2\u00be\u04de\3\2\2\2\u00c0\u04ea\3")
        buf.write("\2\2\2\u00c2\u04f6\3\2\2\2\u00c4\u0508\3\2\2\2\u00c6\u050a")
        buf.write("\3\2\2\2\u00c8\u0513\3\2\2\2\u00ca\u0517\3\2\2\2\u00cc")
        buf.write("\u051c\3\2\2\2\u00ce\u0520\3\2\2\2\u00d0\u0528\3\2\2\2")
        buf.write("\u00d2\u052a\3\2\2\2\u00d4\u0534\3\2\2\2\u00d6\u0551\3")
        buf.write("\2\2\2\u00d8\u0553\3\2\2\2\u00da\u0559\3\2\2\2\u00dc\u0561")
        buf.write("\3\2\2\2\u00de\u0569\3\2\2\2\u00e0\u056b\3\2\2\2\u00e2")
        buf.write("\u0573\3\2\2\2\u00e4\u057b\3\2\2\2\u00e6\u0583\3\2\2\2")
        buf.write("\u00e8\u0587\3\2\2\2\u00ea\u0589\3\2\2\2\u00ec\u0592\3")
        buf.write("\2\2\2\u00ee\u05ad\3\2\2\2\u00f0\u05ba\3\2\2\2\u00f2\u05bc")
        buf.write("\3\2\2\2\u00f4\u05ce\3\2\2\2\u00f6\u05da\3\2\2\2\u00f8")
        buf.write("\u05dd\3\2\2\2\u00fa\u05ef\3\2\2\2\u00fc\u05f1\3\2\2\2")
        buf.write("\u00fe\u05f3\3\2\2\2\u0100\u05f8\3\2\2\2\u0102\u0600\3")
        buf.write("\2\2\2\u0104\u0608\3\2\2\2\u0106\u0610\3\2\2\2\u0108\u061b")
        buf.write("\3\2\2\2\u010a\u0628\3\2\2\2\u010c\u0636\3\2\2\2\u010e")
        buf.write("\u063c\3\2\2\2\u0110\u064c\3\2\2\2\u0112\u064e\3\2\2\2")
        buf.write("\u0114\u0651\3\2\2\2\u0116\u0657\3\2\2\2\u0118\u065e\3")
        buf.write("\2\2\2\u011a\u0660\3\2\2\2\u011c\u0662\3\2\2\2\u011e\u066a")
        buf.write("\3\2\2\2\u0120\u066d\3\2\2\2\u0122\u067b\3\2\2\2\u0124")
        buf.write("\u067d\3\2\2\2\u0126\u0681\3\2\2\2\u0128\u068d\3\2\2\2")
        buf.write("\u012a\u068f\3\2\2\2\u012c\u0699\3\2\2\2\u012e\u069d\3")
        buf.write("\2\2\2\u0130\u06a1\3\2\2\2\u0132\u06a6\3\2\2\2\u0134\u06b0")
        buf.write("\3\2\2\2\u0136\u06b8\3\2\2\2\u0138\u06ba\3\2\2\2\u013a")
        buf.write("\u06bf\3\2\2\2\u013c\u06cd\3\2\2\2\u013e\u06d5\3\2\2\2")
        buf.write("\u0140\u06d8\3\2\2\2\u0142\u06dd\3\2\2\2\u0144\u06f7\3")
        buf.write("\2\2\2\u0146\u06fc\3\2\2\2\u0148\u06ff\3\2\2\2\u014a\u071f")
        buf.write("\3\2\2\2\u014c\u0724\3\2\2\2\u014e\u0727\3\2\2\2\u0150")
        buf.write("\u072b\3\2\2\2\u0152\u072e\3\2\2\2\u0154\u073c\3\2\2\2")
        buf.write("\u0156\u0742\3\2\2\2\u0158\u0744\3\2\2\2\u015a\u0753\3")
        buf.write("\2\2\2\u015c\u0758\3\2\2\2\u015e\u0766\3\2\2\2\u0160\u076b")
        buf.write("\3\2\2\2\u0162\u0771\3\2\2\2\u0164\u0774\3\2\2\2\u0166")
        buf.write("\u077c\3\2\2\2\u0168\u078e\3\2\2\2\u016a\u0793\3\2\2\2")
        buf.write("\u016c\u0797\3\2\2\2\u016e\u07b6\3\2\2\2\u0170\u07b9\3")
        buf.write("\2\2\2\u0172\u07c5\3\2\2\2\u0174\u07d1\3\2\2\2\u0176\u07d3")
        buf.write("\3\2\2\2\u0178\u07d9\3\2\2\2\u017a\u07db\3\2\2\2\u017c")
        buf.write("\u07e1\3\2\2\2\u017e\u07e4\3\2\2\2\u0180\u07ef\3\2\2\2")
        buf.write("\u0182\u07fa\3\2\2\2\u0184\u0800\3\2\2\2\u0186\u0803\3")
        buf.write("\2\2\2\u0188\u080e\3\2\2\2\u018a\u0816\3\2\2\2\u018c\u0820")
        buf.write("\3\2\2\2\u018e\u0824\3\2\2\2\u0190\u0826\3\2\2\2\u0192")
        buf.write("\u082b\3\2\2\2\u0194\u0834\3\2\2\2\u0196\u0841\3\2\2\2")
        buf.write("\u0198\u0844\3\2\2\2\u019a\u084f\3\2\2\2\u019c\u0864\3")
        buf.write("\2\2\2\u019e\u0866\3\2\2\2\u01a0\u086c\3\2\2\2\u01a2\u086f")
        buf.write("\3\2\2\2\u01a4\u0879\3\2\2\2\u01a6\u0886\3\2\2\2\u01a8")
        buf.write("\u0892\3\2\2\2\u01aa\u0894\3\2\2\2\u01ac\u08a6\3\2\2\2")
        buf.write("\u01ae\u08b2\3\2\2\2\u01b0\u08bc\3\2\2\2\u01b2\u08c2\3")
        buf.write("\2\2\2\u01b4\u08d4\3\2\2\2\u01b6\u08f0\3\2\2\2\u01b8\u0909")
        buf.write("\3\2\2\2\u01ba\u090e\3\2\2\2\u01bc\u0918\3\2\2\2\u01be")
        buf.write("\u091a\3\2\2\2\u01c0\u0921\3\2\2\2\u01c2\u0927\3\2\2\2")
        buf.write("\u01c4\u092d\3\2\2\2\u01c6\u0939\3\2\2\2\u01c8\u0947\3")
        buf.write("\2\2\2\u01ca\u0957\3\2\2\2\u01cc\u095c\3\2\2\2\u01ce\u095f")
        buf.write("\3\2\2\2\u01d0\u0963\3\2\2\2\u01d2\u0965\3\2\2\2\u01d4")
        buf.write("\u096e\3\2\2\2\u01d6\u097e\3\2\2\2\u01d8\u0981\3\2\2\2")
        buf.write("\u01da\u0987\3\2\2\2\u01dc\u0995\3\2\2\2\u01de\u0999\3")
        buf.write("\2\2\2\u01e0\u099b\3\2\2\2\u01e2\u09a4\3\2\2\2\u01e4\u09a9")
        buf.write("\3\2\2\2\u01e6\u09af\3\2\2\2\u01e8\u09b9\3\2\2\2\u01ea")
        buf.write("\u09bc\3\2\2\2\u01ec\u09bf\3\2\2\2\u01ee\u09cb\3\2\2\2")
        buf.write("\u01f0\u09cd\3\2\2\2\u01f2\u09db\3\2\2\2\u01f4\u09e9\3")
        buf.write("\2\2\2\u01f6\u09f5\3\2\2\2\u01f8\u09fd\3\2\2\2\u01fa\u0a0a")
        buf.write("\3\2\2\2\u01fc\u0a21\3\2\2\2\u01fe\u0a23\3\2\2\2\u0200")
        buf.write("\u0201\t\2\2\2\u0201\3\3\2\2\2\u0202\u0203\7\4\2\2\u0203")
        buf.write("\u0204\5\u01da\u00ee\2\u0204\5\3\2\2\2\u0205\u0207\5\u00ea")
        buf.write("v\2\u0206\u0208\5\u01ea\u00f6\2\u0207\u0206\3\2\2\2\u0207")
        buf.write("\u0208\3\2\2\2\u0208\u020b\3\2\2\2\u0209\u020a\7\u0089")
        buf.write("\2\2\u020a\u020c\5\u00c2b\2\u020b\u0209\3\2\2\2\u020b")
        buf.write("\u020c\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020e\7\5\2\2")
        buf.write("\u020e\7\3\2\2\2\u020f\u0212\5\u00c2b\2\u0210\u0212\7")
        buf.write(">\2\2\u0211\u020f\3\2\2\2\u0211\u0210\3\2\2\2\u0212\t")
        buf.write("\3\2\2\2\u0213\u0214\5,\27\2\u0214\13\3\2\2\2\u0215\u0216")
        buf.write("\5\u0126\u0094\2\u0216\u0217\7\u008f\2\2\u0217\u0218\5")
        buf.write("\b\5\2\u0218\u0219\7\u0090\2\2\u0219\u021c\3\2\2\2\u021a")
        buf.write("\u021c\5\b\5\2\u021b\u0215\3\2\2\2\u021b\u021a\3\2\2\2")
        buf.write("\u021c\r\3\2\2\2\u021d\u021e\t\3\2\2\u021e\17\3\2\2\2")
        buf.write("\u021f\u0220\7\u008f\2\2\u0220\u0225\5\u0098M\2\u0221")
        buf.write("\u0222\7\u008d\2\2\u0222\u0224\5\u0098M\2\u0223\u0221")
        buf.write("\3\2\2\2\u0224\u0227\3\2\2\2\u0225\u0223\3\2\2\2\u0225")
        buf.write("\u0226\3\2\2\2\u0226\u0228\3\2\2\2\u0227\u0225\3\2\2\2")
        buf.write("\u0228\u0229\7\u0090\2\2\u0229\21\3\2\2\2\u022a\u022b")
        buf.write("\7\7\2\2\u022b\u022e\5\24\13\2\u022c\u022d\7\u0093\2\2")
        buf.write("\u022d\u022f\5\26\f\2\u022e\u022c\3\2\2\2\u022e\u022f")
        buf.write("\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0231\7+\2\2\u0231")
        buf.write("\u0233\5\u0126\u0094\2\u0232\u0234\5\u01aa\u00d6\2\u0233")
        buf.write("\u0232\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0235\3\2\2\2")
        buf.write("\u0235\u0236\7\u008c\2\2\u0236\23\3\2\2\2\u0237\u023b")
        buf.write("\5\u00e8u\2\u0238\u023b\7\u0080\2\2\u0239\u023b\7\u0081")
        buf.write("\2\2\u023a\u0237\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u0239")
        buf.write("\3\2\2\2\u023b\25\3\2\2\2\u023c\u023f\5\u01c4\u00e3\2")
        buf.write("\u023d\u023f\5\u01da\u00ee\2\u023e\u023c\3\2\2\2\u023e")
        buf.write("\u023d\3\2\2\2\u023f\27\3\2\2\2\u0240\u0243\7\66\2\2\u0241")
        buf.write("\u0244\5\u0170\u00b9\2\u0242\u0244\5\u01da\u00ee\2\u0243")
        buf.write("\u0241\3\2\2\2\u0243\u0242\3\2\2\2\u0244\31\3\2\2\2\u0245")
        buf.write("\u0246\7\n\2\2\u0246\u0247\5\u00e8u\2\u0247\u0248\7<\2")
        buf.write("\2\u0248\u0249\5\u00e8u\2\u0249\u024a\7+\2\2\u024a\u024b")
        buf.write("\5\34\17\2\u024b\u024c\7\16\2\2\u024c\u024d\5 \21\2\u024d")
        buf.write("\u024f\7\32\2\2\u024e\u0250\7\n\2\2\u024f\u024e\3\2\2")
        buf.write("\2\u024f\u0250\3\2\2\2\u0250\u0252\3\2\2\2\u0251\u0253")
        buf.write("\5\u00e8u\2\u0252\u0251\3\2\2\2\u0252\u0253\3\2\2\2\u0253")
        buf.write("\u0254\3\2\2\2\u0254\u0255\7\u008c\2\2\u0255\33\3\2\2")
        buf.write("\2\u0256\u0258\5:\36\2\u0257\u0256\3\2\2\2\u0258\u025b")
        buf.write("\3\2\2\2\u0259\u0257\3\2\2\2\u0259\u025a\3\2\2\2\u025a")
        buf.write("\35\3\2\2\2\u025b\u0259\3\2\2\2\u025c\u0272\5B\"\2\u025d")
        buf.write("\u0272\5\u016c\u00b7\2\u025e\u0260\5\u0112\u008a\2\u025f")
        buf.write("\u025e\3\2\2\2\u025f\u0260\3\2\2\2\u0260\u0261\3\2\2\2")
        buf.write("\u0261\u0272\5h\65\2\u0262\u0264\5\u0112\u008a\2\u0263")
        buf.write("\u0262\3\2\2\2\u0263\u0264\3\2\2\2\u0264\u0265\3\2\2\2")
        buf.write("\u0265\u0272\5d\63\2\u0266\u0268\5\u0112\u008a\2\u0267")
        buf.write("\u0266\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u026a\3\2\2\2")
        buf.write("\u0269\u026b\7D\2\2\u026a\u0269\3\2\2\2\u026a\u026b\3")
        buf.write("\2\2\2\u026b\u026c\3\2\2\2\u026c\u0272\5j\66\2\u026d\u0272")
        buf.write("\5\\/\2\u026e\u0272\5\u00d4k\2\u026f\u0272\5f\64\2\u0270")
        buf.write("\u0272\5\u01b8\u00dd\2\u0271\u025c\3\2\2\2\u0271\u025d")
        buf.write("\3\2\2\2\u0271\u025f\3\2\2\2\u0271\u0263\3\2\2\2\u0271")
        buf.write("\u0267\3\2\2\2\u0271\u026d\3\2\2\2\u0271\u026e\3\2\2\2")
        buf.write("\u0271\u026f\3\2\2\2\u0271\u0270\3\2\2\2\u0272\37\3\2")
        buf.write("\2\2\u0273\u0275\5\36\20\2\u0274\u0273\3\2\2\2\u0275\u0278")
        buf.write("\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2\2\2\u0277")
        buf.write("!\3\2\2\2\u0278\u0276\3\2\2\2\u0279\u027c\5\u01f2\u00fa")
        buf.write("\2\u027a\u027c\5\u0082B\2\u027b\u0279\3\2\2\2\u027b\u027a")
        buf.write("\3\2\2\2\u027c#\3\2\2\2\u027d\u0280\5\u01f0\u00f9\2\u027e")
        buf.write("\u0280\5\u0080A\2\u027f\u027d\3\2\2\2\u027f\u027e\3\2")
        buf.write("\2\2\u0280%\3\2\2\2\u0281\u0282\7\f\2\2\u0282\u0285\5")
        buf.write("l\67\2\u0283\u0284\7Q\2\2\u0284\u0286\5\u00c2b\2\u0285")
        buf.write("\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286\u0289\3\2\2\2")
        buf.write("\u0287\u0288\7V\2\2\u0288\u028a\5\u00c2b\2\u0289\u0287")
        buf.write("\3\2\2\2\u0289\u028a\3\2\2\2\u028a\'\3\2\2\2\u028b\u028d")
        buf.write("\5\u0112\u008a\2\u028c\u028b\3\2\2\2\u028c\u028d\3\2\2")
        buf.write("\2\u028d\u028e\3\2\2\2\u028e\u028f\5&\24\2\u028f\u0290")
        buf.write("\7\u008c\2\2\u0290)\3\2\2\2\u0291\u0292\5\u00d0i\2\u0292")
        buf.write("\u0293\7\u0087\2\2\u0293\u0295\3\2\2\2\u0294\u0291\3\2")
        buf.write("\2\2\u0294\u0295\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0297")
        buf.write("\5\f\7\2\u0297+\3\2\2\2\u0298\u029d\5*\26\2\u0299\u029a")
        buf.write("\7\u008d\2\2\u029a\u029c\5*\26\2\u029b\u0299\3\2\2\2\u029c")
        buf.write("\u029f\3\2\2\2\u029d\u029b\3\2\2\2\u029d\u029e\3\2\2\2")
        buf.write("\u029e-\3\2\2\2\u029f\u029d\3\2\2\2\u02a0\u02a1\7\r\2")
        buf.write("\2\u02a1\u02a2\5\u0112\u008a\2\u02a2\u02a3\5\u0126\u0094")
        buf.write("\2\u02a3\u02a4\7\u008c\2\2\u02a4/\3\2\2\2\u02a5\u02ad")
        buf.write("\5\u00e8u\2\u02a6\u02ad\7J\2\2\u02a7\u02ad\7K\2\2\u02a8")
        buf.write("\u02ad\7\5\2\2\u02a9\u02ad\7b\2\2\u02aa\u02ad\7O\2\2\u02ab")
        buf.write("\u02ad\7d\2\2\u02ac\u02a5\3\2\2\2\u02ac\u02a6\3\2\2\2")
        buf.write("\u02ac\u02a7\3\2\2\2\u02ac\u02a8\3\2\2\2\u02ac\u02a9\3")
        buf.write("\2\2\2\u02ac\u02aa\3\2\2\2\u02ac\u02ab\3\2\2\2\u02ad\61")
        buf.write("\3\2\2\2\u02ae\u02af\7\r\2\2\u02af\u02b0\5\60\31\2\u02b0")
        buf.write("\u02b1\7<\2\2\u02b1\u02b2\5\u00b4[\2\u02b2\u02b3\7+\2")
        buf.write("\2\u02b3\u02b4\5\u00c2b\2\u02b4\u02b5\7\u008c\2\2\u02b5")
        buf.write("\63\3\2\2\2\u02b6\u02b7\5\u00e8u\2\u02b7\u02b8\7\u008c")
        buf.write("\2\2\u02b8\65\3\2\2\2\u02b9\u02ba\7j\2\2\u02ba\u02bc\5")
        buf.write("\u00a0Q\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc")
        buf.write("\u02be\3\2\2\2\u02bd\u02bf\5\u00dco\2\u02be\u02bd\3\2")
        buf.write("\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c1\3\2\2\2\u02c0\u02c2")
        buf.write("\5\u0158\u00ad\2\u02c1\u02c0\3\2\2\2\u02c1\u02c2\3\2\2")
        buf.write("\2\u02c2\67\3\2\2\2\u02c3\u02c4\7 \2\2\u02c4\u02c8\5@")
        buf.write("!\2\u02c5\u02c7\5\u01f4\u00fb\2\u02c6\u02c5\3\2\2\2\u02c7")
        buf.write("\u02ca\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c8\u02c9\3\2\2\2")
        buf.write("\u02c9\u02ce\3\2\2\2\u02ca\u02c8\3\2\2\2\u02cb\u02cd\5")
        buf.write("z>\2\u02cc\u02cb\3\2\2\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc")
        buf.write("\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\3\2\2\2\u02d0")
        buf.write("\u02ce\3\2\2\2\u02d1\u02d2\7\32\2\2\u02d2\u02d3\7 \2\2")
        buf.write("\u02d3\u02d4\7\u008c\2\2\u02d49\3\2\2\2\u02d5\u02ec\5")
        buf.write("\u01c8\u00e5\2\u02d6\u02ec\5\u01c6\u00e4\2\u02d7\u02ec")
        buf.write("\5\u01ec\u00f7\2\u02d8\u02ec\5\u01d8\u00ed\2\u02d9\u02ec")
        buf.write("\5~@\2\u02da\u02ec\5\u01a4\u00d3\2\u02db\u02ec\5\u01f8")
        buf.write("\u00fd\2\u02dc\u02ec\5\u00c6d\2\u02dd\u02ec\5\22\n\2\u02de")
        buf.write("\u02ec\5Z.\2\u02df\u02ec\5.\30\2\u02e0\u02ec\5\62\32\2")
        buf.write("\u02e1\u02ec\5|?\2\u02e2\u02ec\5\u0094K\2\u02e3\u02ec")
        buf.write("\5\u01c0\u00e1\2\u02e4\u02ec\5\u01f4\u00fb\2\u02e5\u02ec")
        buf.write("\5\u00e4s\2\u02e6\u02ec\5\u00e2r\2\u02e7\u02ec\5\u0134")
        buf.write("\u009b\2\u02e8\u02ec\5\u01c2\u00e2\2\u02e9\u02ec\5\u0172")
        buf.write("\u00ba\2\u02ea\u02ec\5\u01e4\u00f3\2\u02eb\u02d5\3\2\2")
        buf.write("\2\u02eb\u02d6\3\2\2\2\u02eb\u02d7\3\2\2\2\u02eb\u02d8")
        buf.write("\3\2\2\2\u02eb\u02d9\3\2\2\2\u02eb\u02da\3\2\2\2\u02eb")
        buf.write("\u02db\3\2\2\2\u02eb\u02dc\3\2\2\2\u02eb\u02dd\3\2\2\2")
        buf.write("\u02eb\u02de\3\2\2\2\u02eb\u02df\3\2\2\2\u02eb\u02e0\3")
        buf.write("\2\2\2\u02eb\u02e1\3\2\2\2\u02eb\u02e2\3\2\2\2\u02eb\u02e3")
        buf.write("\3\2\2\2\u02eb\u02e4\3\2\2\2\u02eb\u02e5\3\2\2\2\u02eb")
        buf.write("\u02e6\3\2\2\2\u02eb\u02e7\3\2\2\2\u02eb\u02e8\3\2\2\2")
        buf.write("\u02eb\u02e9\3\2\2\2\u02eb\u02ea\3\2\2\2\u02ec;\3\2\2")
        buf.write("\2\u02ed\u02ef\5:\36\2\u02ee\u02ed\3\2\2\2\u02ef\u02f2")
        buf.write("\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1")
        buf.write("=\3\2\2\2\u02f2\u02f0\3\2\2\2\u02f3\u02f7\5\u00d8m\2\u02f4")
        buf.write("\u02f5\5\u00dco\2\u02f5\u02f6\7\u008c\2\2\u02f6\u02f8")
        buf.write("\3\2\2\2\u02f7\u02f4\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
        buf.write("\u02fa\3\2\2\2\u02f9\u02f3\3\2\2\2\u02f9\u02fa\3\2\2\2")
        buf.write("\u02fa\u0301\3\2\2\2\u02fb\u02ff\5\u0154\u00ab\2\u02fc")
        buf.write("\u02fd\5\u0158\u00ad\2\u02fd\u02fe\7\u008c\2\2\u02fe\u0300")
        buf.write("\3\2\2\2\u02ff\u02fc\3\2\2\2\u02ff\u0300\3\2\2\2\u0300")
        buf.write("\u0302\3\2\2\2\u0301\u02fb\3\2\2\2\u0301\u0302\3\2\2\2")
        buf.write("\u0302?\3\2\2\2\u0303\u0308\5\u00e8u\2\u0304\u0305\7\u008f")
        buf.write("\2\2\u0305\u0306\5\u00f0y\2\u0306\u0307\7\u0090\2\2\u0307")
        buf.write("\u0309\3\2\2\2\u0308\u0304\3\2\2\2\u0308\u0309\3\2\2\2")
        buf.write("\u0309\u030c\3\2\2\2\u030a\u030c\5\u0126\u0094\2\u030b")
        buf.write("\u0303\3\2\2\2\u030b\u030a\3\2\2\2\u030cA\3\2\2\2\u030d")
        buf.write("\u030e\5\u0112\u008a\2\u030e\u0313\7\17\2\2\u030f\u0310")
        buf.write("\7\u008f\2\2\u0310\u0311\5\u00c2b\2\u0311\u0312\7\u0090")
        buf.write("\2\2\u0312\u0314\3\2\2\2\u0313\u030f\3\2\2\2\u0313\u0314")
        buf.write("\3\2\2\2\u0314\u0316\3\2\2\2\u0315\u0317\7+\2\2\u0316")
        buf.write("\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0318\3\2\2\2")
        buf.write("\u0318\u0319\5> \2\u0319\u031a\5<\37\2\u031a\u031b\7\16")
        buf.write("\2\2\u031b\u031c\5D#\2\u031c\u031d\7\32\2\2\u031d\u031f")
        buf.write("\7\17\2\2\u031e\u0320\5\u00e8u\2\u031f\u031e\3\2\2\2\u031f")
        buf.write("\u0320\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0322\7\u008c")
        buf.write("\2\2\u0322C\3\2\2\2\u0323\u0325\5\36\20\2\u0324\u0323")
        buf.write("\3\2\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326")
        buf.write("\u0327\3\2\2\2\u0327E\3\2\2\2\u0328\u0326\3\2\2\2\u0329")
        buf.write("\u032b\7I\2\2\u032a\u032c\5\6\4\2\u032b\u032a\3\2\2\2")
        buf.write("\u032b\u032c\3\2\2\2\u032c\u032e\3\2\2\2\u032d\u032f\5")
        buf.write("\u01e6\u00f4\2\u032e\u032d\3\2\2\2\u032e\u032f\3\2\2\2")
        buf.write("\u032f\u0330\3\2\2\2\u0330\u0331\5\u01e2\u00f2\2\u0331")
        buf.write("\u0332\7\u008c\2\2\u0332G\3\2\2\2\u0333\u0335\5L\'\2\u0334")
        buf.write("\u0333\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0336\3\2\2\2")
        buf.write("\u0336\u0337\5\u0126\u0094\2\u0337\u0338\7\u0087\2\2\u0338")
        buf.write("\u0339\5\u00c2b\2\u0339I\3\2\2\2\u033a\u033f\5H%\2\u033b")
        buf.write("\u033c\7\u008d\2\2\u033c\u033e\5H%\2\u033d\u033b\3\2\2")
        buf.write("\2\u033e\u0341\3\2\2\2\u033f\u033d\3\2\2\2\u033f\u0340")
        buf.write("\3\2\2\2\u0340K\3\2\2\2\u0341\u033f\3\2\2\2\u0342\u0343")
        buf.write("\7 \2\2\u0343\u0344\5\u0126\u0094\2\u0344\u0345\7j\2\2")
        buf.write("\u0345M\3\2\2\2\u0346\u0348\5\u0112\u008a\2\u0347\u0346")
        buf.write("\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0349\3\2\2\2\u0349")
        buf.write("\u034b\7\21\2\2\u034a\u034c\5J&\2\u034b\u034a\3\2\2\2")
        buf.write("\u034b\u034c\3\2\2\2\u034c\u034f\3\2\2\2\u034d\u034e\7")
        buf.write("n\2\2\u034e\u0350\5l\67\2\u034f\u034d\3\2\2\2\u034f\u0350")
        buf.write("\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0352\7\u008c\2\2\u0352")
        buf.write("O\3\2\2\2\u0353\u0355\5\u0112\u008a\2\u0354\u0353\3\2")
        buf.write("\2\2\u0354\u0355\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0357")
        buf.write("\7\24\2\2\u0357\u0358\5\u00c2b\2\u0358\u035a\7+\2\2\u0359")
        buf.write("\u035b\5R*\2\u035a\u0359\3\2\2\2\u035b\u035c\3\2\2\2\u035c")
        buf.write("\u035a\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u035e\3\2\2\2")
        buf.write("\u035e\u035f\7\32\2\2\u035f\u0361\7\24\2\2\u0360\u0362")
        buf.write("\5\u00e8u\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2\u0362")
        buf.write("\u0363\3\2\2\2\u0363\u0364\7\u008c\2\2\u0364Q\3\2\2\2")
        buf.write("\u0365\u0366\7n\2\2\u0366\u0367\5V,\2\u0367\u0368\7\u0087")
        buf.write("\2\2\u0368\u0369\5\u019a\u00ce\2\u0369S\3\2\2\2\u036a")
        buf.write("\u036f\5\u00e8u\2\u036b\u036f\5\u0096L\2\u036c\u036f\5")
        buf.write("\u01ac\u00d7\2\u036d\u036f\7@\2\2\u036e\u036a\3\2\2\2")
        buf.write("\u036e\u036b\3\2\2\2\u036e\u036c\3\2\2\2\u036e\u036d\3")
        buf.write("\2\2\2\u036fU\3\2\2\2\u0370\u0375\5T+\2\u0371\u0372\7")
        buf.write("\u009b\2\2\u0372\u0374\5T+\2\u0373\u0371\3\2\2\2\u0374")
        buf.write("\u0377\3\2\2\2\u0375\u0373\3\2\2\2\u0375\u0376\3\2\2\2")
        buf.write("\u0376W\3\2\2\2\u0377\u0375\3\2\2\2\u0378\u0379\7 \2\2")
        buf.write("\u0379\u037d\5^\60\2\u037a\u037b\5\66\34\2\u037b\u037c")
        buf.write("\7\u008c\2\2\u037c\u037e\3\2\2\2\u037d\u037a\3\2\2\2\u037d")
        buf.write("\u037e\3\2\2\2\u037e\u0380\3\2\2\2\u037f\u0381\58\35\2")
        buf.write("\u0380\u037f\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0382\3")
        buf.write("\2\2\2\u0382\u0383\7\32\2\2\u0383\u0384\7 \2\2\u0384\u0385")
        buf.write("\7\u008c\2\2\u0385Y\3\2\2\2\u0386\u0387\7\25\2\2\u0387")
        buf.write("\u0389\5\u00e8u\2\u0388\u038a\7+\2\2\u0389\u0388\3\2\2")
        buf.write("\2\u0389\u038a\3\2\2\2\u038a\u038c\3\2\2\2\u038b\u038d")
        buf.write("\5\u00d8m\2\u038c\u038b\3\2\2\2\u038c\u038d\3\2\2\2\u038d")
        buf.write("\u038f\3\2\2\2\u038e\u0390\5\u0154\u00ab\2\u038f\u038e")
        buf.write("\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0391\3\2\2\2\u0391")
        buf.write("\u0392\7\32\2\2\u0392\u0394\7\25\2\2\u0393\u0395\5\u00e8")
        buf.write("u\2\u0394\u0393\3\2\2\2\u0394\u0395\3\2\2\2\u0395\u0396")
        buf.write("\3\2\2\2\u0396\u0397\7\u008c\2\2\u0397[\3\2\2\2\u0398")
        buf.write("\u0399\5\u0112\u008a\2\u0399\u039b\5\u00f4{\2\u039a\u039c")
        buf.write("\5\u00dco\2\u039b\u039a\3\2\2\2\u039b\u039c\3\2\2\2\u039c")
        buf.write("\u039e\3\2\2\2\u039d\u039f\5\u0158\u00ad\2\u039e\u039d")
        buf.write("\3\2\2\2\u039e\u039f\3\2\2\2\u039f\u03a0\3\2\2\2\u03a0")
        buf.write("\u03a1\7\u008c\2\2\u03a1]\3\2\2\2\u03a2\u03a3\5\u00f6")
        buf.write("|\2\u03a3\u03a4\7\u0093\2\2\u03a4\u03a5\5\u0126\u0094")
        buf.write("\2\u03a5_\3\2\2\2\u03a6\u03a9\5\"\22\2\u03a7\u03a9\5\u017e")
        buf.write("\u00c0\2\u03a8\u03a6\3\2\2\2\u03a8\u03a7\3\2\2\2\u03a9")
        buf.write("a\3\2\2\2\u03aa\u03ad\5$\23\2\u03ab\u03ad\5\u0180\u00c1")
        buf.write("\2\u03ac\u03aa\3\2\2\2\u03ac\u03ab\3\2\2\2\u03adc\3\2")
        buf.write("\2\2\u03ae\u03b0\5\u0112\u008a\2\u03af\u03ae\3\2\2\2\u03af")
        buf.write("\u03b0\3\2\2\2\u03b0\u03b2\3\2\2\2\u03b1\u03b3\7D\2\2")
        buf.write("\u03b2\u03b1\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3\u03b4\3")
        buf.write("\2\2\2\u03b4\u03b5\5&\24\2\u03b5\u03b6\7\u008c\2\2\u03b6")
        buf.write("e\3\2\2\2\u03b7\u03b9\5\u0112\u008a\2\u03b8\u03b7\3\2")
        buf.write("\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba\3\2\2\2\u03ba\u03bc")
        buf.write("\7\21\2\2\u03bb\u03bd\5J&\2\u03bc\u03bb\3\2\2\2\u03bc")
        buf.write("\u03bd\3\2\2\2\u03bd\u03bf\3\2\2\2\u03be\u03c0\5\u0196")
        buf.write("\u00cc\2\u03bf\u03be\3\2\2\2\u03bf\u03c0\3\2\2\2\u03c0")
        buf.write("\u03c3\3\2\2\2\u03c1\u03c2\7n\2\2\u03c2\u03c4\5l\67\2")
        buf.write("\u03c3\u03c1\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4\u03c5\3")
        buf.write("\2\2\2\u03c5\u03c6\7\u008c\2\2\u03c6g\3\2\2\2\u03c7\u03c9")
        buf.write("\5\u0112\u008a\2\u03c8\u03c7\3\2\2\2\u03c8\u03c9\3\2\2")
        buf.write("\2\u03c9\u03cb\3\2\2\2\u03ca\u03cc\7D\2\2\u03cb\u03ca")
        buf.write("\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd")
        buf.write("\u03ce\5\u0164\u00b3\2\u03ce\u03cf\7\u008c\2\2\u03cfi")
        buf.write("\3\2\2\2\u03d0\u03d2\5\u0112\u008a\2\u03d1\u03d0\3\2\2")
        buf.write("\2\u03d1\u03d2\3\2\2\2\u03d2\u03d4\3\2\2\2\u03d3\u03d5")
        buf.write("\7D\2\2\u03d4\u03d3\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5")
        buf.write("\u03d8\3\2\2\2\u03d6\u03d9\5p9\2\u03d7\u03d9\5\u0192\u00ca")
        buf.write("\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2\2\2\u03d9k\3\2")
        buf.write("\2\2\u03da\u03db\5\u00c2b\2\u03dbm\3\2\2\2\u03dc\u03dd")
        buf.write("\7i\2\2\u03dd\u03de\5l\67\2\u03deo\3\2\2\2\u03df\u03e0")
        buf.write("\5\u01de\u00f0\2\u03e0\u03e1\7\u0085\2\2\u03e1\u03e2\5")
        buf.write("\u0140\u00a1\2\u03e2\u03e3\5r:\2\u03e3\u03e4\7\u008c\2")
        buf.write("\2\u03e4q\3\2\2\2\u03e5\u03ec\5\u01fc\u00ff\2\u03e6\u03e7")
        buf.write("\7n\2\2\u03e7\u03ea\5l\67\2\u03e8\u03e9\7\34\2\2\u03e9")
        buf.write("\u03eb\5r:\2\u03ea\u03e8\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb")
        buf.write("\u03ed\3\2\2\2\u03ec\u03e6\3\2\2\2\u03ec\u03ed\3\2\2\2")
        buf.write("\u03eds\3\2\2\2\u03ee\u03ef\7\26\2\2\u03ef\u03f0\5\u00e8")
        buf.write("u\2\u03f0\u03f1\7<\2\2\u03f1\u03f2\5\u0126\u0094\2\u03f2")
        buf.write("\u03f3\7+\2\2\u03f3\u03f4\5x=\2\u03f4\u03f5\58\35\2\u03f5")
        buf.write("\u03f7\7\32\2\2\u03f6\u03f8\7\26\2\2\u03f7\u03f6\3\2\2")
        buf.write("\2\u03f7\u03f8\3\2\2\2\u03f8\u03fa\3\2\2\2\u03f9\u03fb")
        buf.write("\5\u00e8u\2\u03fa\u03f9\3\2\2\2\u03fa\u03fb\3\2\2\2\u03fb")
        buf.write("\u03fc\3\2\2\2\u03fc\u03fd\7\u008c\2\2\u03fdu\3\2\2\2")
        buf.write("\u03fe\u0402\5\u01f4\u00fb\2\u03ff\u0402\5\62\32\2\u0400")
        buf.write("\u0402\5\u00e2r\2\u0401\u03fe\3\2\2\2\u0401\u03ff\3\2")
        buf.write("\2\2\u0401\u0400\3\2\2\2\u0402w\3\2\2\2\u0403\u0405\5")
        buf.write("v<\2\u0404\u0403\3\2\2\2\u0405\u0408\3\2\2\2\u0406\u0404")
        buf.write("\3\2\2\2\u0406\u0407\3\2\2\2\u0407y\3\2\2\2\u0408\u0406")
        buf.write("\3\2\2\2\u0409\u040c\58\35\2\u040a\u040c\5X-\2\u040b\u0409")
        buf.write("\3\2\2\2\u040b\u040a\3\2\2\2\u040c{\3\2\2\2\u040d\u040e")
        buf.write("\7 \2\2\u040e\u040f\5^\60\2\u040f\u0410\5\66\34\2\u0410")
        buf.write("\u0411\7\u008c\2\2\u0411}\3\2\2\2\u0412\u0413\7\27\2\2")
        buf.write("\u0413\u0414\5\u00eav\2\u0414\u0415\7\u0093\2\2\u0415")
        buf.write("\u0418\5\u01da\u00ee\2\u0416\u0417\7\u0089\2\2\u0417\u0419")
        buf.write("\5\u00c2b\2\u0418\u0416\3\2\2\2\u0418\u0419\3\2\2\2\u0419")
        buf.write("\u041a\3\2\2\2\u041a\u041b\7\u008c\2\2\u041b\177\3\2\2")
        buf.write("\2\u041c\u041d\7\13\2\2\u041d\u041e\5\u00eex\2\u041e\u041f")
        buf.write("\7<\2\2\u041f\u0420\5\u01da\u00ee\2\u0420\u0081\3\2\2")
        buf.write("\2\u0421\u0422\7\13\2\2\u0422\u0423\5\u00eex\2\u0423\u0424")
        buf.write("\7<\2\2\u0424\u0425\5\u01c4\u00e3\2\u0425\u0083\3\2\2")
        buf.write("\2\u0426\u0429\5\u017c\u00bf\2\u0427\u0429\5\u00eex\2")
        buf.write("\u0428\u0426\3\2\2\2\u0428\u0427\3\2\2\2\u0429\u0085\3")
        buf.write("\2\2\2\u042a\u042c\5\u0088E\2\u042b\u042a\3\2\2\2\u042c")
        buf.write("\u042f\3\2\2\2\u042d\u042b\3\2\2\2\u042d\u042e\3\2\2\2")
        buf.write("\u042e\u0087\3\2\2\2\u042f\u042d\3\2\2\2\u0430\u0433\5")
        buf.write("\u0114\u008b\2\u0431\u0433\5\u01f4\u00fb\2\u0432\u0430")
        buf.write("\3\2\2\2\u0432\u0431\3\2\2\2\u0433\u0089\3\2\2\2\u0434")
        buf.write("\u043b\7e\2\2\u0435\u0436\7L\2\2\u0436\u0438\5\u00c2b")
        buf.write("\2\u0437\u0435\3\2\2\2\u0437\u0438\3\2\2\2\u0438\u0439")
        buf.write("\3\2\2\2\u0439\u043b\7)\2\2\u043a\u0434\3\2\2\2\u043a")
        buf.write("\u0437\3\2\2\2\u043b\u008b\3\2\2\2\u043c\u043e\5\u008e")
        buf.write("H\2\u043d\u043c\3\2\2\2\u043e\u0441\3\2\2\2\u043f\u043d")
        buf.write("\3\2\2\2\u043f\u0440\3\2\2\2\u0440\u0442\3\2\2\2\u0441")
        buf.write("\u043f\3\2\2\2\u0442\u0443\7\2\2\3\u0443\u008d\3\2\2\2")
        buf.write("\u0444\u0445\5\u0086D\2\u0445\u0446\5\u0116\u008c\2\u0446")
        buf.write("\u008f\3\2\2\2\u0447\u044a\5\u00e8u\2\u0448\u044a\7\u0081")
        buf.write("\2\2\u0449\u0447\3\2\2\2\u0449\u0448\3\2\2\2\u044a\u0091")
        buf.write("\3\2\2\2\u044b\u044c\t\4\2\2\u044c\u0093\3\2\2\2\u044d")
        buf.write("\u044e\7\30\2\2\u044e\u044f\5\u00e6t\2\u044f\u0450\7\6")
        buf.write("\2\2\u0450\u0451\5\u00c2b\2\u0451\u0452\7\u008c\2\2\u0452")
        buf.write("\u0095\3\2\2\2\u0453\u0456\5\u0178\u00bd\2\u0454\u0456")
        buf.write("\5\u01da\u00ee\2\u0455\u0453\3\2\2\2\u0455\u0454\3\2\2")
        buf.write("\2\u0456\u0097\3\2\2\2\u0457\u0458\5V,\2\u0458\u0459\7")
        buf.write("\u0087\2\2\u0459\u045b\3\2\2\2\u045a\u0457\3\2\2\2\u045a")
        buf.write("\u045b\3\2\2\2\u045b\u045c\3\2\2\2\u045c\u045d\5\u00c2")
        buf.write("b\2\u045d\u0099\3\2\2\2\u045e\u045f\5\u00eav\2\u045f\u0460")
        buf.write("\7\u0093\2\2\u0460\u0461\5\u009eP\2\u0461\u0462\7\u008c")
        buf.write("\2\2\u0462\u009b\3\2\2\2\u0463\u0464\5\u01c4\u00e3\2\u0464")
        buf.write("\u009d\3\2\2\2\u0465\u0466\5\u01da\u00ee\2\u0466\u009f")
        buf.write("\3\2\2\2\u0467\u0468\7\33\2\2\u0468\u046d\5\u0126\u0094")
        buf.write("\2\u0469\u046a\7\u008f\2\2\u046a\u046b\5\u00e8u\2\u046b")
        buf.write("\u046c\7\u0090\2\2\u046c\u046e\3\2\2\2\u046d\u0469\3\2")
        buf.write("\2\2\u046d\u046e\3\2\2\2\u046e\u0473\3\2\2\2\u046f\u0470")
        buf.write("\7\26\2\2\u0470\u0473\5\u0126\u0094\2\u0471\u0473\7>\2")
        buf.write("\2\u0472\u0467\3\2\2\2\u0472\u046f\3\2\2\2\u0472\u0471")
        buf.write("\3\2\2\2\u0473\u00a1\3\2\2\2\u0474\u0475\t\5\2\2\u0475")
        buf.write("\u00a3\3\2\2\2\u0476\u0478\5\u00a2R\2\u0477\u0479\7\u008a")
        buf.write("\2\2\u0478\u0477\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u00a5")
        buf.write("\3\2\2\2\u047a\u047f\5\u00a4S\2\u047b\u047c\7\u008d\2")
        buf.write("\2\u047c\u047e\5\u00a4S\2\u047d\u047b\3\2\2\2\u047e\u0481")
        buf.write("\3\2\2\2\u047f\u047d\3\2\2\2\u047f\u0480\3\2\2\2\u0480")
        buf.write("\u00a7\3\2\2\2\u0481\u047f\3\2\2\2\u0482\u0483\7\33\2")
        buf.write("\2\u0483\u0484\5\u00e8u\2\u0484\u0485\7+\2\2\u0485\u0486")
        buf.write("\5\u00b0Y\2\u0486\u0489\5\u00acW\2\u0487\u0488\7\16\2")
        buf.write("\2\u0488\u048a\5\u00b8]\2\u0489\u0487\3\2\2\2\u0489\u048a")
        buf.write("\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048d\7\32\2\2\u048c")
        buf.write("\u048e\7\33\2\2\u048d\u048c\3\2\2\2\u048d\u048e\3\2\2")
        buf.write("\2\u048e\u0490\3\2\2\2\u048f\u0491\5\u00e8u\2\u0490\u048f")
        buf.write("\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0492\3\2\2\2\u0492")
        buf.write("\u0493\7\u008c\2\2\u0493\u00a9\3\2\2\2\u0494\u04a9\5\u01c8")
        buf.write("\u00e5\2\u0495\u04a9\5\u01c6\u00e4\2\u0496\u04a9\5\u01ec")
        buf.write("\u00f7\2\u0497\u04a9\5\u01d8\u00ed\2\u0498\u04a9\5~@\2")
        buf.write("\u0499\u04a9\5\u01a4\u00d3\2\u049a\u04a9\5\u01f8\u00fd")
        buf.write("\2\u049b\u04a9\5\u00c6d\2\u049c\u04a9\5\22\n\2\u049d\u04a9")
        buf.write("\5.\30\2\u049e\u04a9\5\62\32\2\u049f\u04a9\5\u0094K\2")
        buf.write("\u04a0\u04a9\5\u01c0\u00e1\2\u04a1\u04a9\5\u01f4\u00fb")
        buf.write("\2\u04a2\u04a9\5\u00e4s\2\u04a3\u04a9\5\u00e2r\2\u04a4")
        buf.write("\u04a9\5\u0134\u009b\2\u04a5\u04a9\5\u01c2\u00e2\2\u04a6")
        buf.write("\u04a9\5\u0172\u00ba\2\u04a7\u04a9\5\u01e4\u00f3\2\u04a8")
        buf.write("\u0494\3\2\2\2\u04a8\u0495\3\2\2\2\u04a8\u0496\3\2\2\2")
        buf.write("\u04a8\u0497\3\2\2\2\u04a8\u0498\3\2\2\2\u04a8\u0499\3")
        buf.write("\2\2\2\u04a8\u049a\3\2\2\2\u04a8\u049b\3\2\2\2\u04a8\u049c")
        buf.write("\3\2\2\2\u04a8\u049d\3\2\2\2\u04a8\u049e\3\2\2\2\u04a8")
        buf.write("\u049f\3\2\2\2\u04a8\u04a0\3\2\2\2\u04a8\u04a1\3\2\2\2")
        buf.write("\u04a8\u04a2\3\2\2\2\u04a8\u04a3\3\2\2\2\u04a8\u04a4\3")
        buf.write("\2\2\2\u04a8\u04a5\3\2\2\2\u04a8\u04a6\3\2\2\2\u04a8\u04a7")
        buf.write("\3\2\2\2\u04a9\u00ab\3\2\2\2\u04aa\u04ac\5\u00aaV\2\u04ab")
        buf.write("\u04aa\3\2\2\2\u04ac\u04af\3\2\2\2\u04ad\u04ab\3\2\2\2")
        buf.write("\u04ad\u04ae\3\2\2\2\u04ae\u00ad\3\2\2\2\u04af\u04ad\3")
        buf.write("\2\2\2\u04b0\u04b2\5\u00ba^\2\u04b1\u04b3\5\u01aa\u00d6")
        buf.write("\2\u04b2\u04b1\3\2\2\2\u04b2\u04b3\3\2\2\2\u04b3\u00af")
        buf.write("\3\2\2\2\u04b4\u04b6\5\u00d8m\2\u04b5\u04b4\3\2\2\2\u04b5")
        buf.write("\u04b6\3\2\2\2\u04b6\u04b8\3\2\2\2\u04b7\u04b9\5\u0154")
        buf.write("\u00ab\2\u04b8\u04b7\3\2\2\2\u04b8\u04b9\3\2\2\2\u04b9")
        buf.write("\u00b1\3\2\2\2\u04ba\u04bf\5\u00aeX\2\u04bb\u04bc\7\u008d")
        buf.write("\2\2\u04bc\u04be\5\u00aeX\2\u04bd\u04bb\3\2\2\2\u04be")
        buf.write("\u04c1\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf\u04c0\3\2\2\2")
        buf.write("\u04c0\u04c5\3\2\2\2\u04c1\u04bf\3\2\2\2\u04c2\u04c5\7")
        buf.write("@\2\2\u04c3\u04c5\7\b\2\2\u04c4\u04ba\3\2\2\2\u04c4\u04c2")
        buf.write("\3\2\2\2\u04c4\u04c3\3\2\2\2\u04c5\u00b3\3\2\2\2\u04c6")
        buf.write("\u04c7\5\u00b2Z\2\u04c7\u04c8\7\u0093\2\2\u04c8\u04c9")
        buf.write("\5\u00a2R\2\u04c9\u00b5\3\2\2\2\u04ca\u04ce\5d\63\2\u04cb")
        buf.write("\u04ce\5\u016c\u00b7\2\u04cc\u04ce\5h\65\2\u04cd\u04ca")
        buf.write("\3\2\2\2\u04cd\u04cb\3\2\2\2\u04cd\u04cc\3\2\2\2\u04ce")
        buf.write("\u00b7\3\2\2\2\u04cf\u04d1\5\u00b6\\\2\u04d0\u04cf\3\2")
        buf.write("\2\2\u04d1\u04d4\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2\u04d3")
        buf.write("\3\2\2\2\u04d3\u00b9\3\2\2\2\u04d4\u04d2\3\2\2\2\u04d5")
        buf.write("\u04d9\5\u00e8u\2\u04d6\u04d9\7\u0080\2\2\u04d7\u04d9")
        buf.write("\7\u0081\2\2\u04d8\u04d5\3\2\2\2\u04d8\u04d6\3\2\2\2\u04d8")
        buf.write("\u04d7\3\2\2\2\u04d9\u00bb\3\2\2\2\u04da\u04dd\5\u00e8")
        buf.write("u\2\u04db\u04dd\7\u0080\2\2\u04dc\u04da\3\2\2\2\u04dc")
        buf.write("\u04db\3\2\2\2\u04dd\u00bd\3\2\2\2\u04de\u04df\7\u008f")
        buf.write("\2\2\u04df\u04e4\5\u00bc_\2\u04e0\u04e1\7\u008d\2\2\u04e1")
        buf.write("\u04e3\5\u00bc_\2\u04e2\u04e0\3\2\2\2\u04e3\u04e6\3\2")
        buf.write("\2\2\u04e4\u04e2\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5\u04e7")
        buf.write("\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e7\u04e8\7\u0090\2\2\u04e8")
        buf.write("\u00bf\3\2\2\2\u04e9\u04eb\5\u0112\u008a\2\u04ea\u04e9")
        buf.write("\3\2\2\2\u04ea\u04eb\3\2\2\2\u04eb\u04ec\3\2\2\2\u04ec")
        buf.write("\u04ee\7\36\2\2\u04ed\u04ef\5\u00e8u\2\u04ee\u04ed\3\2")
        buf.write("\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f2\3\2\2\2\u04f0\u04f1")
        buf.write("\7n\2\2\u04f1\u04f3\5l\67\2\u04f2\u04f0\3\2\2\2\u04f2")
        buf.write("\u04f3\3\2\2\2\u04f3\u04f4\3\2\2\2\u04f4\u04f5\7\u008c")
        buf.write("\2\2\u04f5\u00c1\3\2\2\2\u04f6\u04fc\5\u0182\u00c2\2\u04f7")
        buf.write("\u04f8\5\u011e\u0090\2\u04f8\u04f9\5\u0182\u00c2\2\u04f9")
        buf.write("\u04fb\3\2\2\2\u04fa\u04f7\3\2\2\2\u04fb\u04fe\3\2\2\2")
        buf.write("\u04fc\u04fa\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u00c3\3")
        buf.write("\2\2\2\u04fe\u04fc\3\2\2\2\u04ff\u0502\5\u015a\u00ae\2")
        buf.write("\u0500\u0501\7\u0083\2\2\u0501\u0503\5\u015a\u00ae\2\u0502")
        buf.write("\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0509\3\2\2\2")
        buf.write("\u0504\u0505\7\3\2\2\u0505\u0509\5\u015a\u00ae\2\u0506")
        buf.write("\u0507\7:\2\2\u0507\u0509\5\u015a\u00ae\2\u0508\u04ff")
        buf.write("\3\2\2\2\u0508\u0504\3\2\2\2\u0508\u0506\3\2\2\2\u0509")
        buf.write("\u00c5\3\2\2\2\u050a\u050b\7\37\2\2\u050b\u050c\5\u00ea")
        buf.write("v\2\u050c\u050d\7\u0093\2\2\u050d\u050f\5\u01da\u00ee")
        buf.write("\2\u050e\u0510\5\u00caf\2\u050f\u050e\3\2\2\2\u050f\u0510")
        buf.write("\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u0512\7\u008c\2\2\u0512")
        buf.write("\u00c7\3\2\2\2\u0513\u0514\5\u00c2b\2\u0514\u00c9\3\2")
        buf.write("\2\2\u0515\u0516\7>\2\2\u0516\u0518\5\u00c2b\2\u0517\u0515")
        buf.write("\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u0519\3\2\2\2\u0519")
        buf.write("\u051a\7+\2\2\u051a\u051b\5\u00c8e\2\u051b\u00cb\3\2\2")
        buf.write("\2\u051c\u051d\7\37\2\2\u051d\u051e\7<\2\2\u051e\u051f")
        buf.write("\5\u01da\u00ee\2\u051f\u00cd\3\2\2\2\u0520\u0521\5\u0104")
        buf.write("\u0083\2\u0521\u00cf\3\2\2\2\u0522\u0529\5\u00e8u\2\u0523")
        buf.write("\u0524\5\u00e8u\2\u0524\u0525\7\u008f\2\2\u0525\u0526")
        buf.write("\5\u017a\u00be\2\u0526\u0527\7\u0090\2\2\u0527\u0529\3")
        buf.write("\2\2\2\u0528\u0522\3\2\2\2\u0528\u0523\3\2\2\2\u0529\u00d1")
        buf.write("\3\2\2\2\u052a\u052b\7I\2\2\u052b\u052c\5\u00eav\2\u052c")
        buf.write("\u052d\7\u0093\2\2\u052d\u0530\5\u01da\u00ee\2\u052e\u052f")
        buf.write("\7\u0089\2\2\u052f\u0531\5\u00c2b\2\u0530\u052e\3\2\2")
        buf.write("\2\u0530\u0531\3\2\2\2\u0531\u0532\3\2\2\2\u0532\u0533")
        buf.write("\7\u008c\2\2\u0533\u00d3\3\2\2\2\u0534\u0535\5\u0112\u008a")
        buf.write("\2\u0535\u0536\5\u00d6l\2\u0536\u053e\7\"\2\2\u0537\u0539")
        buf.write("\5:\36\2\u0538\u0537\3\2\2\2\u0539\u053c\3\2\2\2\u053a")
        buf.write("\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053d\3\2\2\2")
        buf.write("\u053c\u053a\3\2\2\2\u053d\u053f\7\16\2\2\u053e\u053a")
        buf.write("\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0543\3\2\2\2\u0540")
        buf.write("\u0542\5\36\20\2\u0541\u0540\3\2\2\2\u0542\u0545\3\2\2")
        buf.write("\2\u0543\u0541\3\2\2\2\u0543\u0544\3\2\2\2\u0544\u0546")
        buf.write("\3\2\2\2\u0545\u0543\3\2\2\2\u0546\u0547\7\32\2\2\u0547")
        buf.write("\u0549\7\"\2\2\u0548\u054a\5\u00e8u\2\u0549\u0548\3\2")
        buf.write("\2\2\u0549\u054a\3\2\2\2\u054a\u054b\3\2\2\2\u054b\u054c")
        buf.write("\7\u008c\2\2\u054c\u00d5\3\2\2\2\u054d\u054e\7 \2\2\u054e")
        buf.write("\u0552\5\u014e\u00a8\2\u054f\u0550\7&\2\2\u0550\u0552")
        buf.write("\5l\67\2\u0551\u054d\3\2\2\2\u0551\u054f\3\2\2\2\u0552")
        buf.write("\u00d7\3\2\2\2\u0553\u0554\7#\2\2\u0554\u0555\7\u008f")
        buf.write("\2\2\u0555\u0556\5\u00dan\2\u0556\u0557\7\u0090\2\2\u0557")
        buf.write("\u0558\7\u008c\2\2\u0558\u00d9\3\2\2\2\u0559\u055e\5\u00f8")
        buf.write("}\2\u055a\u055b\7\u008c\2\2\u055b\u055d\5\u00f8}\2\u055c")
        buf.write("\u055a\3\2\2\2\u055d\u0560\3\2\2\2\u055e\u055c\3\2\2\2")
        buf.write("\u055e\u055f\3\2\2\2\u055f\u00db\3\2\2\2\u0560\u055e\3")
        buf.write("\2\2\2\u0561\u0562\7#\2\2\u0562\u0563\7\62\2\2\u0563\u0564")
        buf.write("\7\u008f\2\2\u0564\u0565\5,\27\2\u0565\u0566\7\u0090\2")
        buf.write("\2\u0566\u00dd\3\2\2\2\u0567\u056a\5\u0126\u0094\2\u0568")
        buf.write("\u056a\7\u0080\2\2\u0569\u0567\3\2\2\2\u0569\u0568\3\2")
        buf.write("\2\2\u056a\u00df\3\2\2\2\u056b\u0570\5\u00dep\2\u056c")
        buf.write("\u056d\7\u008d\2\2\u056d\u056f\5\u00dep\2\u056e\u056c")
        buf.write("\3\2\2\2\u056f\u0572\3\2\2\2\u0570\u056e\3\2\2\2\u0570")
        buf.write("\u0571\3\2\2\2\u0571\u00e1\3\2\2\2\u0572\u0570\3\2\2\2")
        buf.write("\u0573\u0574\7$\2\2\u0574\u0575\5\u0112\u008a\2\u0575")
        buf.write("\u0576\5\u0126\u0094\2\u0576\u0577\7\u008f\2\2\u0577\u0578")
        buf.write("\5\u00e0q\2\u0578\u0579\7\u0090\2\2\u0579\u057a\7\u008c")
        buf.write("\2\2\u057a\u00e3\3\2\2\2\u057b\u057c\7$\2\2\u057c\u057d")
        buf.write("\5\u00e8u\2\u057d\u057e\7+\2\2\u057e\u057f\7\u008f\2\2")
        buf.write("\u057f\u0580\5\u00a6T\2\u0580\u0581\7\u0090\2\2\u0581")
        buf.write("\u0582\7\u008c\2\2\u0582\u00e5\3\2\2\2\u0583\u0584\5\u01a8")
        buf.write("\u00d5\2\u0584\u0585\7\u0093\2\2\u0585\u0586\5\u0126\u0094")
        buf.write("\2\u0586\u00e7\3\2\2\2\u0587\u0588\t\6\2\2\u0588\u00e9")
        buf.write("\3\2\2\2\u0589\u058e\5\u00e8u\2\u058a\u058b\7\u008d\2")
        buf.write("\2\u058b\u058d\5\u00e8u\2\u058c\u058a\3\2\2\2\u058d\u0590")
        buf.write("\3\2\2\2\u058e\u058c\3\2\2\2\u058e\u058f\3\2\2\2\u058f")
        buf.write("\u00eb\3\2\2\2\u0590\u058e\3\2\2\2\u0591\u0593\5\u0112")
        buf.write("\u008a\2\u0592\u0591\3\2\2\2\u0592\u0593\3\2\2\2\u0593")
        buf.write("\u0594\3\2\2\2\u0594\u0595\7&\2\2\u0595\u0596\5l\67\2")
        buf.write("\u0596\u0597\7a\2\2\u0597\u059f\5\u019a\u00ce\2\u0598")
        buf.write("\u0599\7\35\2\2\u0599\u059a\5l\67\2\u059a\u059b\7a\2\2")
        buf.write("\u059b\u059c\5\u019a\u00ce\2\u059c\u059e\3\2\2\2\u059d")
        buf.write("\u0598\3\2\2\2\u059e\u05a1\3\2\2\2\u059f\u059d\3\2\2\2")
        buf.write("\u059f\u05a0\3\2\2\2\u05a0\u05a4\3\2\2\2\u05a1\u059f\3")
        buf.write("\2\2\2\u05a2\u05a3\7\34\2\2\u05a3\u05a5\5\u019a\u00ce")
        buf.write("\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a6")
        buf.write("\3\2\2\2\u05a6\u05a7\7\32\2\2\u05a7\u05a9\7&\2\2\u05a8")
        buf.write("\u05aa\5\u00e8u\2\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2")
        buf.write("\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ac\7\u008c\2\2\u05ac")
        buf.write("\u00ed\3\2\2\2\u05ad\u05ae\7\u008f\2\2\u05ae\u05b3\5\u0096")
        buf.write("L\2\u05af\u05b0\7\u008d\2\2\u05b0\u05b2\5\u0096L\2\u05b1")
        buf.write("\u05af\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2")
        buf.write("\u05b3\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3")
        buf.write("\2\2\2\u05b6\u05b7\7\u0090\2\2\u05b7\u00ef\3\2\2\2\u05b8")
        buf.write("\u05bb\5\u0096L\2\u05b9\u05bb\5\u00c2b\2\u05ba\u05b8\3")
        buf.write("\2\2\2\u05ba\u05b9\3\2\2\2\u05bb\u00f1\3\2\2\2\u05bc\u05bd")
        buf.write("\5\u0126\u0094\2\u05bd\u05be\7J\2\2\u05be\u05bf\7\u008a")
        buf.write("\2\2\u05bf\u00f3\3\2\2\2\u05c0\u05c2\7\25\2\2\u05c1\u05c0")
        buf.write("\3\2\2\2\u05c1\u05c2\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3")
        buf.write("\u05cf\5\u0126\u0094\2\u05c4\u05c5\7\33\2\2\u05c5\u05ca")
        buf.write("\5\u0126\u0094\2\u05c6\u05c7\7\u008f\2\2\u05c7\u05c8\5")
        buf.write("\u00e8u\2\u05c8\u05c9\7\u0090\2\2\u05c9\u05cb\3\2\2\2")
        buf.write("\u05ca\u05c6\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cf\3")
        buf.write("\2\2\2\u05cc\u05cd\7\26\2\2\u05cd\u05cf\5\u0126\u0094")
        buf.write("\2\u05ce\u05c1\3\2\2\2\u05ce\u05c4\3\2\2\2\u05ce\u05cc")
        buf.write("\3\2\2\2\u05cf\u00f5\3\2\2\2\u05d0\u05d5\5\u00e8u\2\u05d1")
        buf.write("\u05d2\7\u008d\2\2\u05d2\u05d4\5\u00e8u\2\u05d3\u05d1")
        buf.write("\3\2\2\2\u05d4\u05d7\3\2\2\2\u05d5\u05d3\3\2\2\2\u05d5")
        buf.write("\u05d6\3\2\2\2\u05d6\u05db\3\2\2\2\u05d7\u05d5\3\2\2\2")
        buf.write("\u05d8\u05db\7@\2\2\u05d9\u05db\7\b\2\2\u05da\u05d0\3")
        buf.write("\2\2\2\u05da\u05d8\3\2\2\2\u05da\u05d9\3\2\2\2\u05db\u00f7")
        buf.write("\3\2\2\2\u05dc\u05de\7\27\2\2\u05dd\u05dc\3\2\2\2\u05dd")
        buf.write("\u05de\3\2\2\2\u05de\u05df\3\2\2\2\u05df\u05e0\5\u00ea")
        buf.write("v\2\u05e0\u05e2\7\u0093\2\2\u05e1\u05e3\7(\2\2\u05e2\u05e1")
        buf.write("\3\2\2\2\u05e2\u05e3\3\2\2\2\u05e3\u05e4\3\2\2\2\u05e4")
        buf.write("\u05e7\5\u01da\u00ee\2\u05e5\u05e6\7\u0089\2\2\u05e6\u05e8")
        buf.write("\5\u00c2b\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2\2\2\u05e8")
        buf.write("\u00f9\3\2\2\2\u05e9\u05f0\5\u00f8}\2\u05ea\u05f0\5\u010a")
        buf.write("\u0086\2\u05eb\u05f0\5\u010e\u0088\2\u05ec\u05f0\5\u00fe")
        buf.write("\u0080\2\u05ed\u05f0\5\u010c\u0087\2\u05ee\u05f0\5\u0106")
        buf.write("\u0084\2\u05ef\u05e9\3\2\2\2\u05ef\u05ea\3\2\2\2\u05ef")
        buf.write("\u05eb\3\2\2\2\u05ef\u05ec\3\2\2\2\u05ef\u05ed\3\2\2\2")
        buf.write("\u05ef\u05ee\3\2\2\2\u05f0\u00fb\3\2\2\2\u05f1\u05f2\5")
        buf.write("\u00fa~\2\u05f2\u00fd\3\2\2\2\u05f3\u05f4\7\37\2\2\u05f4")
        buf.write("\u05f5\5\u00eav\2\u05f5\u05f6\7\u0093\2\2\u05f6\u05f7")
        buf.write("\5\u01da\u00ee\2\u05f7\u00ff\3\2\2\2\u05f8\u05fd\5\u010a")
        buf.write("\u0086\2\u05f9\u05fa\7\u008c\2\2\u05fa\u05fc\5\u010a\u0086")
        buf.write("\2\u05fb\u05f9\3\2\2\2\u05fc\u05ff\3\2\2\2\u05fd\u05fb")
        buf.write("\3\2\2\2\u05fd\u05fe\3\2\2\2\u05fe\u0101\3\2\2\2\u05ff")
        buf.write("\u05fd\3\2\2\2\u0600\u0605\5\u0108\u0085\2\u0601\u0602")
        buf.write("\7\u008c\2\2\u0602\u0604\5\u0108\u0085\2\u0603\u0601\3")
        buf.write("\2\2\2\u0604\u0607\3\2\2\2\u0605\u0603\3\2\2\2\u0605\u0606")
        buf.write("\3\2\2\2\u0606\u0103\3\2\2\2\u0607\u0605\3\2\2\2\u0608")
        buf.write("\u060d\5\u00fc\177\2\u0609\u060a\7\u008c\2\2\u060a\u060c")
        buf.write("\5\u00fc\177\2\u060b\u0609\3\2\2\2\u060c\u060f\3\2\2\2")
        buf.write("\u060d\u060b\3\2\2\2\u060d\u060e\3\2\2\2\u060e\u0105\3")
        buf.write("\2\2\2\u060f\u060d\3\2\2\2\u0610\u0611\7I\2\2\u0611\u0612")
        buf.write("\5\u00eav\2\u0612\u0614\7\u0093\2\2\u0613\u0615\t\7\2")
        buf.write("\2\u0614\u0613\3\2\2\2\u0614\u0615\3\2\2\2\u0615\u0616")
        buf.write("\3\2\2\2\u0616\u0619\5\u01da\u00ee\2\u0617\u0618\7\u0089")
        buf.write("\2\2\u0618\u061a\5\u00c2b\2\u0619\u0617\3\2\2\2\u0619")
        buf.write("\u061a\3\2\2\2\u061a\u0107\3\2\2\2\u061b\u061c\5\u00ea")
        buf.write("v\2\u061c\u061e\7\u0093\2\2\u061d\u061f\5\u0122\u0092")
        buf.write("\2\u061e\u061d\3\2\2\2\u061e\u061f\3\2\2\2\u061f\u0620")
        buf.write("\3\2\2\2\u0620\u0622\5\u01da\u00ee\2\u0621\u0623\7\23")
        buf.write("\2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0626")
        buf.write("\3\2\2\2\u0624\u0625\7\u0089\2\2\u0625\u0627\5\u00c2b")
        buf.write("\2\u0626\u0624\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0109")
        buf.write("\3\2\2\2\u0628\u0629\7X\2\2\u0629\u062a\5\u00eav\2\u062a")
        buf.write("\u062c\7\u0093\2\2\u062b\u062d\5\u0122\u0092\2\u062c\u062b")
        buf.write("\3\2\2\2\u062c\u062d\3\2\2\2\u062d\u062e\3\2\2\2\u062e")
        buf.write("\u0630\5\u01da\u00ee\2\u062f\u0631\7\23\2\2\u0630\u062f")
        buf.write("\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0634\3\2\2\2\u0632")
        buf.write("\u0633\7\u0089\2\2\u0633\u0635\5\u00c2b\2\u0634\u0632")
        buf.write("\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u010b\3\2\2\2\u0636")
        buf.write("\u0637\7`\2\2\u0637\u0638\5\u00eav\2\u0638\u0639\7\u0093")
        buf.write("\2\2\u0639\u063a\5\u01c4\u00e3\2\u063a\u010d\3\2\2\2\u063b")
        buf.write("\u063d\7k\2\2\u063c\u063b\3\2\2\2\u063c\u063d\3\2\2\2")
        buf.write("\u063d\u063e\3\2\2\2\u063e\u063f\5\u00eav\2\u063f\u0641")
        buf.write("\7\u0093\2\2\u0640\u0642\5\u0122\u0092\2\u0641\u0640\3")
        buf.write("\2\2\2\u0641\u0642\3\2\2\2\u0642\u0643\3\2\2\2\u0643\u0646")
        buf.write("\5\u01da\u00ee\2\u0644\u0645\7\u0089\2\2\u0645\u0647\5")
        buf.write("\u00c2b\2\u0646\u0644\3\2\2\2\u0646\u0647\3\2\2\2\u0647")
        buf.write("\u010f\3\2\2\2\u0648\u0649\7o\2\2\u0649\u064d\5l\67\2")
        buf.write("\u064a\u064b\7 \2\2\u064b\u064d\5\u014e\u00a8\2\u064c")
        buf.write("\u0648\3\2\2\2\u064c\u064a\3\2\2\2\u064d\u0111\3\2\2\2")
        buf.write("\u064e\u064f\5\u00e8u\2\u064f\u0650\7\u0093\2\2\u0650")
        buf.write("\u0113\3\2\2\2\u0651\u0652\7-\2\2\u0652\u0653\5\u011c")
        buf.write("\u008f\2\u0653\u0654\7\u008c\2\2\u0654\u0115\3\2\2\2\u0655")
        buf.write("\u0658\5\u018e\u00c8\2\u0656\u0658\5\u015c\u00af\2\u0657")
        buf.write("\u0655\3\2\2\2\u0657\u0656\3\2\2\2\u0658\u0117\3\2\2\2")
        buf.write("\u0659\u065f\7;\2\2\u065a\u065f\7s\2\2\u065b\u065f\7\u0081")
        buf.write("\2\2\u065c\u065f\5\u00bc_\2\u065d\u065f\5\u013c\u009f")
        buf.write("\2\u065e\u0659\3\2\2\2\u065e\u065a\3\2\2\2\u065e\u065b")
        buf.write("\3\2\2\2\u065e\u065c\3\2\2\2\u065e\u065d\3\2\2\2\u065f")
        buf.write("\u0119\3\2\2\2\u0660\u0661\5\u00e8u\2\u0661\u011b\3\2")
        buf.write("\2\2\u0662\u0667\5\u011a\u008e\2\u0663\u0664\7\u008d\2")
        buf.write("\2\u0664\u0666\5\u011a\u008e\2\u0665\u0663\3\2\2\2\u0666")
        buf.write("\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0667\u0668\3\2\2\2")
        buf.write("\u0668\u011d\3\2\2\2\u0669\u0667\3\2\2\2\u066a\u066b\t")
        buf.write("\b\2\2\u066b\u011f\3\2\2\2\u066c\u066e\5\u0112\u008a\2")
        buf.write("\u066d\u066c\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u0670\3")
        buf.write("\2\2\2\u066f\u0671\5\u0110\u0089\2\u0670\u066f\3\2\2\2")
        buf.write("\u0670\u0671\3\2\2\2\u0671\u0672\3\2\2\2\u0672\u0673\7")
        buf.write("\61\2\2\u0673\u0674\5\u019a\u00ce\2\u0674\u0675\7\32\2")
        buf.write("\2\u0675\u0677\7\61\2\2\u0676\u0678\5\u00e8u\2\u0677\u0676")
        buf.write("\3\2\2\2\u0677\u0678\3\2\2\2\u0678\u0679\3\2\2\2\u0679")
        buf.write("\u067a\7\u008c\2\2\u067a\u0121\3\2\2\2\u067b\u067c\t\t")
        buf.write("\2\2\u067c\u0123\3\2\2\2\u067d\u067e\t\n\2\2\u067e\u0125")
        buf.write("\3\2\2\2\u067f\u0682\5\u00e8u\2\u0680\u0682\7\u0081\2")
        buf.write("\2\u0681\u067f\3\2\2\2\u0681\u0680\3\2\2\2\u0682\u0686")
        buf.write("\3\2\2\2\u0683\u0685\5\u0128\u0095\2\u0684\u0683\3\2\2")
        buf.write("\2\u0685\u0688\3\2\2\2\u0686\u0684\3\2\2\2\u0686\u0687")
        buf.write("\3\2\2\2\u0687\u0127\3\2\2\2\u0688\u0686\3\2\2\2\u0689")
        buf.write("\u068e\5\u012c\u0097\2\u068a\u068e\5\u012e\u0098\2\u068b")
        buf.write("\u068e\5\u0130\u0099\2\u068c\u068e\5\u0132\u009a\2\u068d")
        buf.write("\u0689\3\2\2\2\u068d\u068a\3\2\2\2\u068d\u068b\3\2\2\2")
        buf.write("\u068d\u068c\3\2\2\2\u068e\u0129\3\2\2\2\u068f\u0694\5")
        buf.write("\u00e8u\2\u0690\u0691\7\u009c\2\2\u0691\u0693\5\u01dc")
        buf.write("\u00ef\2\u0692\u0690\3\2\2\2\u0693\u0696\3\2\2\2\u0694")
        buf.write("\u0692\3\2\2\2\u0694\u0695\3\2\2\2\u0695\u012b\3\2\2\2")
        buf.write("\u0696\u0694\3\2\2\2\u0697\u0698\7\u009c\2\2\u0698\u069a")
        buf.write("\5\u01dc\u00ef\2\u0699\u0697\3\2\2\2\u069a\u069b\3\2\2")
        buf.write("\2\u069b\u0699\3\2\2\2\u069b\u069c\3\2\2\2\u069c\u012d")
        buf.write("\3\2\2\2\u069d\u069e\7\u008f\2\2\u069e\u069f\5\n\6\2\u069f")
        buf.write("\u06a0\7\u0090\2\2\u06a0\u012f\3\2\2\2\u06a1\u06a2\7\u008f")
        buf.write("\2\2\u06a2\u06a3\5\u0096L\2\u06a3\u06a4\7\u0090\2\2\u06a4")
        buf.write("\u0131\3\2\2\2\u06a5\u06a7\5\u01aa\u00d6\2\u06a6\u06a5")
        buf.write("\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8")
        buf.write("\u06a9\7\u00a4\2\2\u06a9\u06ae\5\60\31\2\u06aa\u06ab\7")
        buf.write("\u008f\2\2\u06ab\u06ac\5\u00c2b\2\u06ac\u06ad\7\u0090")
        buf.write("\2\2\u06ad\u06af\3\2\2\2\u06ae\u06aa\3\2\2\2\u06ae\u06af")
        buf.write("\3\2\2\2\u06af\u0133\3\2\2\2\u06b0\u06b1\7\65\2\2\u06b1")
        buf.write("\u06b2\5\u00e8u\2\u06b2\u06b3\7+\2\2\u06b3\u06b4\5\u0136")
        buf.write("\u009c\2\u06b4\u06b5\7\u008c\2\2\u06b5\u0135\3\2\2\2\u06b6")
        buf.write("\u06b9\5\u018a\u00c6\2\u06b7\u06b9\5`\61\2\u06b8\u06b6")
        buf.write("\3\2\2\2\u06b8\u06b7\3\2\2\2\u06b9\u0137\3\2\2\2\u06ba")
        buf.write("\u06bb\5\u00eav\2\u06bb\u06bc\7\u0093\2\2\u06bc\u06bd")
        buf.write("\5\u009cO\2\u06bd\u0139\3\2\2\2\u06be\u06c0\5\u0112\u008a")
        buf.write("\2\u06bf\u06be\3\2\2\2\u06bf\u06c0\3\2\2\2\u06c0\u06c1")
        buf.write("\3\2\2\2\u06c1\u06c3\7\67\2\2\u06c2\u06c4\5\u00e8u\2\u06c3")
        buf.write("\u06c2\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2")
        buf.write("\u06c5\u06c6\7n\2\2\u06c6\u06c8\5l\67\2\u06c7\u06c5\3")
        buf.write("\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca")
        buf.write("\7\u008c\2\2\u06ca\u013b\3\2\2\2\u06cb\u06ce\5\2\2\2\u06cc")
        buf.write("\u06ce\5\u0150\u00a9\2\u06cd\u06cb\3\2\2\2\u06cd\u06cc")
        buf.write("\3\2\2\2\u06ce\u013d\3\2\2\2\u06cf\u06d6\5~@\2\u06d0\u06d6")
        buf.write("\5\u01a4\u00d3\2\u06d1\u06d6\5\u01f8\u00fd\2\u06d2\u06d6")
        buf.write("\5\u00c6d\2\u06d3\u06d6\5\u01e4\u00f3\2\u06d4\u06d6\5")
        buf.write("\u0172\u00ba\2\u06d5\u06cf\3\2\2\2\u06d5\u06d0\3\2\2\2")
        buf.write("\u06d5\u06d1\3\2\2\2\u06d5\u06d2\3\2\2\2\u06d5\u06d3\3")
        buf.write("\2\2\2\u06d5\u06d4\3\2\2\2\u06d6\u013f\3\2\2\2\u06d7\u06d9")
        buf.write("\7%\2\2\u06d8\u06d7\3\2\2\2\u06d8\u06d9\3\2\2\2\u06d9")
        buf.write("\u06db\3\2\2\2\u06da\u06dc\5\u008aF\2\u06db\u06da\3\2")
        buf.write("\2\2\u06db\u06dc\3\2\2\2\u06dc\u0141\3\2\2\2\u06dd\u06de")
        buf.write("\7B\2\2\u06de\u06df\7\20\2\2\u06df\u06e0\5\u00e8u\2\u06e0")
        buf.write("\u06e1\7+\2\2\u06e1\u06e2\5\u0146\u00a4\2\u06e2\u06e5")
        buf.write("\7\32\2\2\u06e3\u06e4\7B\2\2\u06e4\u06e6\7\20\2\2\u06e5")
        buf.write("\u06e3\3\2\2\2\u06e5\u06e6\3\2\2\2\u06e6\u06e8\3\2\2\2")
        buf.write("\u06e7\u06e9\5\u00e8u\2\u06e8\u06e7\3\2\2\2\u06e8\u06e9")
        buf.write("\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7\u008c\2\2\u06eb")
        buf.write("\u0143\3\2\2\2\u06ec\u06f8\5\u01c8\u00e5\2\u06ed\u06f8")
        buf.write("\5\u01c6\u00e4\2\u06ee\u06f8\5\u01ec\u00f7\2\u06ef\u06f8")
        buf.write("\5\u01d8\u00ed\2\u06f0\u06f8\5~@\2\u06f1\u06f8\5\u01f8")
        buf.write("\u00fd\2\u06f2\u06f8\5\u00c6d\2\u06f3\u06f8\5\22\n\2\u06f4")
        buf.write("\u06f8\5\u01f4\u00fb\2\u06f5\u06f8\5\u00e4s\2\u06f6\u06f8")
        buf.write("\5\u00e2r\2\u06f7\u06ec\3\2\2\2\u06f7\u06ed\3\2\2\2\u06f7")
        buf.write("\u06ee\3\2\2\2\u06f7\u06ef\3\2\2\2\u06f7\u06f0\3\2\2\2")
        buf.write("\u06f7\u06f1\3\2\2\2\u06f7\u06f2\3\2\2\2\u06f7\u06f3\3")
        buf.write("\2\2\2\u06f7\u06f4\3\2\2\2\u06f7\u06f5\3\2\2\2\u06f7\u06f6")
        buf.write("\3\2\2\2\u06f8\u0145\3\2\2\2\u06f9\u06fb\5\u0144\u00a3")
        buf.write("\2\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa")
        buf.write("\3\2\2\2\u06fc\u06fd\3\2\2\2\u06fd\u0147\3\2\2\2\u06fe")
        buf.write("\u06fc\3\2\2\2\u06ff\u0700\7B\2\2\u0700\u0701\5\u00e8")
        buf.write("u\2\u0701\u0702\7+\2\2\u0702\u0703\5\u014c\u00a7\2\u0703")
        buf.write("\u0705\7\32\2\2\u0704\u0706\7B\2\2\u0705\u0704\3\2\2\2")
        buf.write("\u0705\u0706\3\2\2\2\u0706\u0708\3\2\2\2\u0707\u0709\5")
        buf.write("\u00e8u\2\u0708\u0707\3\2\2\2\u0708\u0709\3\2\2\2\u0709")
        buf.write("\u070a\3\2\2\2\u070a\u070b\7\u008c\2\2\u070b\u0149\3\2")
        buf.write("\2\2\u070c\u0720\5\u01c8\u00e5\2\u070d\u0720\5\u01c6\u00e4")
        buf.write("\2\u070e\u0720\5\u01ec\u00f7\2\u070f\u0720\5\u01d8\u00ed")
        buf.write("\2\u0710\u0720\5~@\2\u0711\u0720\5\u01a4\u00d3\2\u0712")
        buf.write("\u0720\5\u01f8\u00fd\2\u0713\u0720\5\u00c6d\2\u0714\u0720")
        buf.write("\5\22\n\2\u0715\u0720\5Z.\2\u0716\u0720\5.\30\2\u0717")
        buf.write("\u0720\5\62\32\2\u0718\u0720\5\u0094K\2\u0719\u0720\5")
        buf.write("\u01f4\u00fb\2\u071a\u0720\5\u00e4s\2\u071b\u0720\5\u00e2")
        buf.write("r\2\u071c\u0720\5\u0134\u009b\2\u071d\u0720\5\u01c2\u00e2")
        buf.write("\2\u071e\u0720\5\u01e4\u00f3\2\u071f\u070c\3\2\2\2\u071f")
        buf.write("\u070d\3\2\2\2\u071f\u070e\3\2\2\2\u071f\u070f\3\2\2\2")
        buf.write("\u071f\u0710\3\2\2\2\u071f\u0711\3\2\2\2\u071f\u0712\3")
        buf.write("\2\2\2\u071f\u0713\3\2\2\2\u071f\u0714\3\2\2\2\u071f\u0715")
        buf.write("\3\2\2\2\u071f\u0716\3\2\2\2\u071f\u0717\3\2\2\2\u071f")
        buf.write("\u0718\3\2\2\2\u071f\u0719\3\2\2\2\u071f\u071a\3\2\2\2")
        buf.write("\u071f\u071b\3\2\2\2\u071f\u071c\3\2\2\2\u071f\u071d\3")
        buf.write("\2\2\2\u071f\u071e\3\2\2\2\u0720\u014b\3\2\2\2\u0721\u0723")
        buf.write("\5\u014a\u00a6\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2")
        buf.write("\2\u0724\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u014d")
        buf.write("\3\2\2\2\u0726\u0724\3\2\2\2\u0727\u0728\5\u00e8u\2\u0728")
        buf.write("\u0729\7(\2\2\u0729\u072a\5\u0096L\2\u072a\u014f\3\2\2")
        buf.write("\2\u072b\u072c\5\2\2\2\u072c\u072d\5\u00e8u\2\u072d\u0151")
        buf.write("\3\2\2\2\u072e\u072f\5\u017c\u00bf\2\u072f\u0730\7h\2")
        buf.write("\2\u0730\u0734\5\64\33\2\u0731\u0733\5\u0190\u00c9\2\u0732")
        buf.write("\u0731\3\2\2\2\u0733\u0736\3\2\2\2\u0734\u0732\3\2\2\2")
        buf.write("\u0734\u0735\3\2\2\2\u0735\u0737\3\2\2\2\u0736\u0734\3")
        buf.write("\2\2\2\u0737\u0738\7\32\2\2\u0738\u073a\7h\2\2\u0739\u073b")
        buf.write("\5\u00e8u\2\u073a\u0739\3\2\2\2\u073a\u073b\3\2\2\2\u073b")
        buf.write("\u0153\3\2\2\2\u073c\u073d\7C\2\2\u073d\u073e\7\u008f")
        buf.write("\2\2\u073e\u073f\5\u0156\u00ac\2\u073f\u0740\7\u0090\2")
        buf.write("\2\u0740\u0741\7\u008c\2\2\u0741\u0155\3\2\2\2\u0742\u0743")
        buf.write("\5\u0102\u0082\2\u0743\u0157\3\2\2\2\u0744\u0745\7C\2")
        buf.write("\2\u0745\u0746\7\62\2\2\u0746\u0747\7\u008f\2\2\u0747")
        buf.write("\u0748\5,\27\2\u0748\u0749\7\u0090\2\2\u0749\u0159\3\2")
        buf.write("\2\2\u074a\u0754\5\u0118\u008d\2\u074b\u0754\5\u0170\u00b9")
        buf.write("\2\u074c\u074d\7\u008f\2\2\u074d\u074e\5\u00c2b\2\u074e")
        buf.write("\u074f\7\u0090\2\2\u074f\u0754\3\2\2\2\u0750\u0754\5\30")
        buf.write("\r\2\u0751\u0754\5\20\t\2\u0752\u0754\5\u0126\u0094\2")
        buf.write("\u0753\u074a\3\2\2\2\u0753\u074b\3\2\2\2\u0753\u074c\3")
        buf.write("\2\2\2\u0753\u0750\3\2\2\2\u0753\u0751\3\2\2\2\u0753\u0752")
        buf.write("\3\2\2\2\u0754\u015b\3\2\2\2\u0755\u0759\5\u00a8U\2\u0756")
        buf.write("\u0759\5t;\2\u0757\u0759\5\u0148\u00a5\2\u0758\u0755\3")
        buf.write("\2\2\2\u0758\u0756\3\2\2\2\u0758\u0757\3\2\2\2\u0759\u015d")
        buf.write("\3\2\2\2\u075a\u0767\5\u01c8\u00e5\2\u075b\u0767\5\u01c6")
        buf.write("\u00e4\2\u075c\u0767\5\u01ec\u00f7\2\u075d\u0767\5\u01d8")
        buf.write("\u00ed\2\u075e\u0767\5~@\2\u075f\u0767\5\u01f8\u00fd\2")
        buf.write("\u0760\u0767\5\22\n\2\u0761\u0767\5.\30\2\u0762\u0767")
        buf.write("\5\62\32\2\u0763\u0767\5\u01f4\u00fb\2\u0764\u0767\5\u00e4")
        buf.write("s\2\u0765\u0767\5\u00e2r\2\u0766\u075a\3\2\2\2\u0766\u075b")
        buf.write("\3\2\2\2\u0766\u075c\3\2\2\2\u0766\u075d\3\2\2\2\u0766")
        buf.write("\u075e\3\2\2\2\u0766\u075f\3\2\2\2\u0766\u0760\3\2\2\2")
        buf.write("\u0766\u0761\3\2\2\2\u0766\u0762\3\2\2\2\u0766\u0763\3")
        buf.write("\2\2\2\u0766\u0764\3\2\2\2\u0766\u0765\3\2\2\2\u0767\u015f")
        buf.write("\3\2\2\2\u0768\u076a\5\u015e\u00b0\2\u0769\u0768\3\2\2")
        buf.write("\2\u076a\u076d\3\2\2\2\u076b\u0769\3\2\2\2\u076b\u076c")
        buf.write("\3\2\2\2\u076c\u0161\3\2\2\2\u076d\u076b\3\2\2\2\u076e")
        buf.write("\u0770\5\u019c\u00cf\2\u076f\u076e\3\2\2\2\u0770\u0773")
        buf.write("\3\2\2\2\u0771\u076f\3\2\2\2\u0771\u0772\3\2\2\2\u0772")
        buf.write("\u0163\3\2\2\2\u0773\u0771\3\2\2\2\u0774\u0779\5\u012a")
        buf.write("\u0096\2\u0775\u0776\7\u008f\2\2\u0776\u0777\5\n\6\2\u0777")
        buf.write("\u0778\7\u0090\2\2\u0778\u077a\3\2\2\2\u0779\u0775\3\2")
        buf.write("\2\2\u0779\u077a\3\2\2\2\u077a\u0165\3\2\2\2\u077b\u077d")
        buf.write("\5\u0112\u008a\2\u077c\u077b\3\2\2\2\u077c\u077d\3\2\2")
        buf.write("\2\u077d\u077e\3\2\2\2\u077e\u077f\5\u0164\u00b3\2\u077f")
        buf.write("\u0780\7\u008c\2\2\u0780\u0167\3\2\2\2\u0781\u078f\5\u01c8")
        buf.write("\u00e5\2\u0782\u078f\5\u01c6\u00e4\2\u0783\u078f\5\u01ec")
        buf.write("\u00f7\2\u0784\u078f\5\u01d8\u00ed\2\u0785\u078f\5~@\2")
        buf.write("\u0786\u078f\5\u01f8\u00fd\2\u0787\u078f\5\u00c6d\2\u0788")
        buf.write("\u078f\5\22\n\2\u0789\u078f\5.\30\2\u078a\u078f\5\62\32")
        buf.write("\2\u078b\u078f\5\u01f4\u00fb\2\u078c\u078f\5\u00e4s\2")
        buf.write("\u078d\u078f\5\u00e2r\2\u078e\u0781\3\2\2\2\u078e\u0782")
        buf.write("\3\2\2\2\u078e\u0783\3\2\2\2\u078e\u0784\3\2\2\2\u078e")
        buf.write("\u0785\3\2\2\2\u078e\u0786\3\2\2\2\u078e\u0787\3\2\2\2")
        buf.write("\u078e\u0788\3\2\2\2\u078e\u0789\3\2\2\2\u078e\u078a\3")
        buf.write("\2\2\2\u078e\u078b\3\2\2\2\u078e\u078c\3\2\2\2\u078e\u078d")
        buf.write("\3\2\2\2\u078f\u0169\3\2\2\2\u0790\u0792\5\u0168\u00b5")
        buf.write("\2\u0791\u0790\3\2\2\2\u0792\u0795\3\2\2\2\u0793\u0791")
        buf.write("\3\2\2\2\u0793\u0794\3\2\2\2\u0794\u016b\3\2\2\2\u0795")
        buf.write("\u0793\3\2\2\2\u0796\u0798\5\u0112\u008a\2\u0797\u0796")
        buf.write("\3\2\2\2\u0797\u0798\3\2\2\2\u0798\u079a\3\2\2\2\u0799")
        buf.write("\u079b\7D\2\2\u079a\u0799\3\2\2\2\u079a\u079b\3\2\2\2")
        buf.write("\u079b\u079c\3\2\2\2\u079c\u07a1\7E\2\2\u079d\u079e\7")
        buf.write("\u008f\2\2\u079e\u079f\5\u0198\u00cd\2\u079f\u07a0\7\u0090")
        buf.write("\2\2\u07a0\u07a2\3\2\2\2\u07a1\u079d\3\2\2\2\u07a1\u07a2")
        buf.write("\3\2\2\2\u07a2\u07a4\3\2\2\2\u07a3\u07a5\7+\2\2\u07a4")
        buf.write("\u07a3\3\2\2\2\u07a4\u07a5\3\2\2\2\u07a5\u07a6\3\2\2\2")
        buf.write("\u07a6\u07a7\5\u016a\u00b6\2\u07a7\u07a8\7\16\2\2\u07a8")
        buf.write("\u07a9\5\u016e\u00b8\2\u07a9\u07ab\7\32\2\2\u07aa\u07ac")
        buf.write("\7D\2\2\u07ab\u07aa\3\2\2\2\u07ab\u07ac\3\2\2\2\u07ac")
        buf.write("\u07ad\3\2\2\2\u07ad\u07af\7E\2\2\u07ae\u07b0\5\u00e8")
        buf.write("u\2\u07af\u07ae\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1")
        buf.write("\3\2\2\2\u07b1\u07b2\7\u008c\2\2\u07b2\u016d\3\2\2\2\u07b3")
        buf.write("\u07b5\5\u019c\u00cf\2\u07b4\u07b3\3\2\2\2\u07b5\u07b8")
        buf.write("\3\2\2\2\u07b6\u07b4\3\2\2\2\u07b6\u07b7\3\2\2\2\u07b7")
        buf.write("\u016f\3\2\2\2\u07b8\u07b6\3\2\2\2\u07b9\u07ba\5\u01da")
        buf.write("\u00ee\2\u07ba\u07c0\7\u00a4\2\2\u07bb\u07c1\5\20\t\2")
        buf.write("\u07bc\u07bd\7\u008f\2\2\u07bd\u07be\5\u00c2b\2\u07be")
        buf.write("\u07bf\7\u0090\2\2\u07bf\u07c1\3\2\2\2\u07c0\u07bb\3\2")
        buf.write("\2\2\u07c0\u07bc\3\2\2\2\u07c1\u0171\3\2\2\2\u07c2\u07c6")
        buf.write("\5\u00d2j\2\u07c3\u07c6\5F$\2\u07c4\u07c6\5\u01be\u00e0")
        buf.write("\2\u07c5\u07c2\3\2\2\2\u07c5\u07c3\3\2\2\2\u07c5\u07c4")
        buf.write("\3\2\2\2\u07c6\u0173\3\2\2\2\u07c7\u07cc\5\u0126\u0094")
        buf.write("\2\u07c8\u07c9\7\u008d\2\2\u07c9\u07cb\5\u0126\u0094\2")
        buf.write("\u07ca\u07c8\3\2\2\2\u07cb\u07ce\3\2\2\2\u07cc\u07ca\3")
        buf.write("\2\2\2\u07cc\u07cd\3\2\2\2\u07cd\u07d2\3\2\2\2\u07ce\u07cc")
        buf.write("\3\2\2\2\u07cf\u07d2\7@\2\2\u07d0\u07d2\7\b\2\2\u07d1")
        buf.write("\u07c7\3\2\2\2\u07d1\u07cf\3\2\2\2\u07d1\u07d0\3\2\2\2")
        buf.write("\u07d2\u0175\3\2\2\2\u07d3\u07d4\5\u0174\u00bb\2\u07d4")
        buf.write("\u07d5\7\u0093\2\2\u07d5\u07d6\5\u0126\u0094\2\u07d6\u0177")
        buf.write("\3\2\2\2\u07d7\u07da\5\u017a\u00be\2\u07d8\u07da\5\u0126")
        buf.write("\u0094\2\u07d9\u07d7\3\2\2\2\u07d9\u07d8\3\2\2\2\u07da")
        buf.write("\u0179\3\2\2\2\u07db\u07df\5\u01ac\u00d7\2\u07dc\u07dd")
        buf.write("\5\u0092J\2\u07dd\u07de\5\u01ac\u00d7\2\u07de\u07e0\3")
        buf.write("\2\2\2\u07df\u07dc\3\2\2\2\u07df\u07e0\3\2\2\2\u07e0\u017b")
        buf.write("\3\2\2\2\u07e1\u07e2\7J\2\2\u07e2\u07e3\5\u0178\u00bd")
        buf.write("\2\u07e3\u017d\3\2\2\2\u07e4\u07e6\7N\2\2\u07e5\u07e7")
        buf.write("\5\u0138\u009d\2\u07e6\u07e5\3\2\2\2\u07e7\u07e8\3\2\2")
        buf.write("\2\u07e8\u07e6\3\2\2\2\u07e8\u07e9\3\2\2\2\u07e9\u07ea")
        buf.write("\3\2\2\2\u07ea\u07eb\7\32\2\2\u07eb\u07ed\7N\2\2\u07ec")
        buf.write("\u07ee\5\u00e8u\2\u07ed\u07ec\3\2\2\2\u07ed\u07ee\3\2")
        buf.write("\2\2\u07ee\u017f\3\2\2\2\u07ef\u07f1\7N\2\2\u07f0\u07f2")
        buf.write("\5\u009aN\2\u07f1\u07f0\3\2\2\2\u07f2\u07f3\3\2\2\2\u07f3")
        buf.write("\u07f1\3\2\2\2\u07f3\u07f4\3\2\2\2\u07f4\u07f5\3\2\2\2")
        buf.write("\u07f5\u07f6\7\32\2\2\u07f6\u07f8\7N\2\2\u07f7\u07f9\5")
        buf.write("\u00e8u\2\u07f8\u07f7\3\2\2\2\u07f8\u07f9\3\2\2\2\u07f9")
        buf.write("\u0181\3\2\2\2\u07fa\u07fe\5\u019e\u00d0\2\u07fb\u07fc")
        buf.write("\5\u0184\u00c3\2\u07fc\u07fd\5\u019e\u00d0\2\u07fd\u07ff")
        buf.write("\3\2\2\2\u07fe\u07fb\3\2\2\2\u07fe\u07ff\3\2\2\2\u07ff")
        buf.write("\u0183\3\2\2\2\u0800\u0801\t\13\2\2\u0801\u0185\3\2\2")
        buf.write("\2\u0802\u0804\5\u0112\u008a\2\u0803\u0802\3\2\2\2\u0803")
        buf.write("\u0804\3\2\2\2\u0804\u0805\3\2\2\2\u0805\u0806\7Q\2\2")
        buf.write("\u0806\u0809\5\u00c2b\2\u0807\u0808\7V\2\2\u0808\u080a")
        buf.write("\5\u00c2b\2\u0809\u0807\3\2\2\2\u0809\u080a\3\2\2\2\u080a")
        buf.write("\u080b\3\2\2\2\u080b\u080c\7\u008c\2\2\u080c\u0187\3\2")
        buf.write("\2\2\u080d\u080f\5\u0112\u008a\2\u080e\u080d\3\2\2\2\u080e")
        buf.write("\u080f\3\2\2\2\u080f\u0810\3\2\2\2\u0810\u0812\7R\2\2")
        buf.write("\u0811\u0813\5\u00c2b\2\u0812\u0811\3\2\2\2\u0812\u0813")
        buf.write("\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0815\7\u008c\2\2\u0815")
        buf.write("\u0189\3\2\2\2\u0816\u0817\5\u0126\u0094\2\u0817\u0818")
        buf.write("\7\5\2\2\u0818\u0819\5\u0126\u0094\2\u0819\u081a\7b\2")
        buf.write("\2\u081a\u081b\5\u0126\u0094\2\u081b\u081c\7O\2\2\u081c")
        buf.write("\u018b\3\2\2\2\u081d\u0821\5\u0152\u00aa\2\u081e\u0821")
        buf.write("\5\u00be`\2\u081f\u0821\5\u017c\u00bf\2\u0820\u081d\3")
        buf.write("\2\2\2\u0820\u081e\3\2\2\2\u0820\u081f\3\2\2\2\u0821\u018d")
        buf.write("\3\2\2\2\u0822\u0825\5\32\16\2\u0823\u0825\5\u0142\u00a2")
        buf.write("\2\u0824\u0822\3\2\2\2\u0824\u0823\3\2\2\2\u0825\u018f")
        buf.write("\3\2\2\2\u0826\u0827\5\u00e8u\2\u0827\u0828\7\u009a\2")
        buf.write("\2\u0828\u0829\5\u0150\u00a9\2\u0829\u082a\7\u008c\2\2")
        buf.write("\u082a\u0191\3\2\2\2\u082b\u082c\7m\2\2\u082c\u082d\5")
        buf.write("\u00c2b\2\u082d\u082e\7U\2\2\u082e\u082f\5\u01de\u00f0")
        buf.write("\2\u082f\u0830\7\u0085\2\2\u0830\u0831\5\u0140\u00a1\2")
        buf.write("\u0831\u0832\5\u0194\u00cb\2\u0832\u0833\7\u008c\2\2\u0833")
        buf.write("\u0193\3\2\2\2\u0834\u0835\5\u01fc\u00ff\2\u0835\u0836")
        buf.write("\7n\2\2\u0836\u083e\5V,\2\u0837\u0838\7\u008d\2\2\u0838")
        buf.write("\u0839\5\u01fc\u00ff\2\u0839\u083a\7n\2\2\u083a\u083b")
        buf.write("\5V,\2\u083b\u083d\3\2\2\2\u083c\u0837\3\2\2\2\u083d\u0840")
        buf.write("\3\2\2\2\u083e\u083c\3\2\2\2\u083e\u083f\3\2\2\2\u083f")
        buf.write("\u0195\3\2\2\2\u0840\u083e\3\2\2\2\u0841\u0842\7=\2\2")
        buf.write("\u0842\u0843\5\u0198\u00cd\2\u0843\u0197\3\2\2\2\u0844")
        buf.write("\u0849\5\u0126\u0094\2\u0845\u0846\7\u008d\2\2\u0846\u0848")
        buf.write("\5\u0126\u0094\2\u0847\u0845\3\2\2\2\u0848\u084b\3\2\2")
        buf.write("\2\u0849\u0847\3\2\2\2\u0849\u084a\3\2\2\2\u084a\u0199")
        buf.write("\3\2\2\2\u084b\u0849\3\2\2\2\u084c\u084e\5\u019c\u00cf")
        buf.write("\2\u084d\u084c\3\2\2\2\u084e\u0851\3\2\2\2\u084f\u084d")
        buf.write("\3\2\2\2\u084f\u0850\3\2\2\2\u0850\u019b\3\2\2\2\u0851")
        buf.write("\u084f\3\2\2\2\u0852\u0865\5\u01fa\u00fe\2\u0853\u0865")
        buf.write("\5(\25\2\u0854\u0865\5\u0186\u00c4\2\u0855\u0865\5\u01a2")
        buf.write("\u00d2\2\u0856\u0865\5\u01f6\u00fc\2\u0857\u0865\5\u00ec")
        buf.write("w\2\u0858\u0865\5P)\2\u0859\u0865\5\u0120\u0091\2\u085a")
        buf.write("\u0865\5\u013a\u009e\2\u085b\u0865\5\u00c0a\2\u085c\u0865")
        buf.write("\5\u0188\u00c5\2\u085d\u085f\5\u0112\u008a\2\u085e\u085d")
        buf.write("\3\2\2\2\u085e\u085f\3\2\2\2\u085f\u0860\3\2\2\2\u0860")
        buf.write("\u0861\7;\2\2\u0861\u0865\7\u008c\2\2\u0862\u0865\5N(")
        buf.write("\2\u0863\u0865\5\u0166\u00b4\2\u0864\u0852\3\2\2\2\u0864")
        buf.write("\u0853\3\2\2\2\u0864\u0854\3\2\2\2\u0864\u0855\3\2\2\2")
        buf.write("\u0864\u0856\3\2\2\2\u0864\u0857\3\2\2\2\u0864\u0858\3")
        buf.write("\2\2\2\u0864\u0859\3\2\2\2\u0864\u085a\3\2\2\2\u0864\u085b")
        buf.write("\3\2\2\2\u0864\u085c\3\2\2\2\u0864\u085e\3\2\2\2\u0864")
        buf.write("\u0862\3\2\2\2\u0864\u0863\3\2\2\2\u0865\u019d\3\2\2\2")
        buf.write("\u0866\u086a\5\u01ac\u00d7\2\u0867\u0868\5\u01a0\u00d1")
        buf.write("\2\u0868\u0869\5\u01ac\u00d7\2\u0869\u086b\3\2\2\2\u086a")
        buf.write("\u0867\3\2\2\2\u086a\u086b\3\2\2\2\u086b\u019f\3\2\2\2")
        buf.write("\u086c\u086d\t\f\2\2\u086d\u01a1\3\2\2\2\u086e\u0870\5")
        buf.write("\u0112\u008a\2\u086f\u086e\3\2\2\2\u086f\u0870\3\2\2\2")
        buf.write("\u0870\u0871\3\2\2\2\u0871\u0872\5\u01de\u00f0\2\u0872")
        buf.write("\u0874\7\u0085\2\2\u0873\u0875\5\u008aF\2\u0874\u0873")
        buf.write("\3\2\2\2\u0874\u0875\3\2\2\2\u0875\u0876\3\2\2\2\u0876")
        buf.write("\u0877\5\u01fc\u00ff\2\u0877\u0878\7\u008c\2\2\u0878\u01a3")
        buf.write("\3\2\2\2\u0879\u087a\7X\2\2\u087a\u087b\5\u00eav\2\u087b")
        buf.write("\u087c\7\u0093\2\2\u087c\u087e\5\u01da\u00ee\2\u087d\u087f")
        buf.write("\5\u01a6\u00d4\2\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2")
        buf.write("\2\u087f\u0882\3\2\2\2\u0880\u0881\7\u0089\2\2\u0881\u0883")
        buf.write("\5\u00c2b\2\u0882\u0880\3\2\2\2\u0882\u0883\3\2\2\2\u0883")
        buf.write("\u0884\3\2\2\2\u0884\u0885\7\u008c\2\2\u0885\u01a5\3\2")
        buf.write("\2\2\u0886\u0887\t\r\2\2\u0887\u01a7\3\2\2\2\u0888\u088d")
        buf.write("\5\u0126\u0094\2\u0889\u088a\7\u008d\2\2\u088a\u088c\5")
        buf.write("\u0126\u0094\2\u088b\u0889\3\2\2\2\u088c\u088f\3\2\2\2")
        buf.write("\u088d\u088b\3\2\2\2\u088d\u088e\3\2\2\2\u088e\u0893\3")
        buf.write("\2\2\2\u088f\u088d\3\2\2\2\u0890\u0893\7@\2\2\u0891\u0893")
        buf.write("\7\b\2\2\u0892\u0888\3\2\2\2\u0892\u0890\3\2\2\2\u0892")
        buf.write("\u0891\3\2\2\2\u0893\u01a9\3\2\2\2\u0894\u089d\7\u0091")
        buf.write("\2\2\u0895\u089a\5\u0126\u0094\2\u0896\u0897\7\u008d\2")
        buf.write("\2\u0897\u0899\5\u0126\u0094\2\u0898\u0896\3\2\2\2\u0899")
        buf.write("\u089c\3\2\2\2\u089a\u0898\3\2\2\2\u089a\u089b\3\2\2\2")
        buf.write("\u089b\u089e\3\2\2\2\u089c\u089a\3\2\2\2\u089d\u0895\3")
        buf.write("\2\2\2\u089d\u089e\3\2\2\2\u089e\u08a1\3\2\2\2\u089f\u08a0")
        buf.write("\7R\2\2\u08a0\u08a2\5\u0126\u0094\2\u08a1\u089f\3\2\2")
        buf.write("\2\u08a1\u08a2\3\2\2\2\u08a2\u08a3\3\2\2\2\u08a3\u08a4")
        buf.write("\7\u0092\2\2\u08a4\u01ab\3\2\2\2\u08a5\u08a7\t\16\2\2")
        buf.write("\u08a6\u08a5\3\2\2\2\u08a6\u08a7\3\2\2\2\u08a7\u08a8\3")
        buf.write("\2\2\2\u08a8\u08ae\5\u01e0\u00f1\2\u08a9\u08aa\5\16\b")
        buf.write("\2\u08aa\u08ab\5\u01e0\u00f1\2\u08ab\u08ad\3\2\2\2\u08ac")
        buf.write("\u08a9\3\2\2\2\u08ad\u08b0\3\2\2\2\u08ae\u08ac\3\2\2\2")
        buf.write("\u08ae\u08af\3\2\2\2\u08af\u01ad\3\2\2\2\u08b0\u08ae\3")
        buf.write("\2\2\2\u08b1\u08b3\5\u0112\u008a\2\u08b2\u08b1\3\2\2\2")
        buf.write("\u08b2\u08b3\3\2\2\2\u08b3\u08b4\3\2\2\2\u08b4\u08b5\5")
        buf.write("\u01ac\u00d7\2\u08b5\u08b6\7\u0084\2\2\u08b6\u08b8\5\u01ac")
        buf.write("\u00d7\2\u08b7\u08b9\5\u01ea\u00f6\2\u08b8\u08b7\3\2\2")
        buf.write("\2\u08b8\u08b9\3\2\2\2\u08b9\u08ba\3\2\2\2\u08ba\u08bb")
        buf.write("\7\u008c\2\2\u08bb\u01af\3\2\2\2\u08bc\u08bd\7n\2\2\u08bd")
        buf.write("\u08be\5V,\2\u08be\u08bf\7\u0087\2\2\u08bf\u08c0\5\u01ba")
        buf.write("\u00de\2\u08c0\u01b1\3\2\2\2\u08c1\u08c3\5\u0112\u008a")
        buf.write("\2\u08c2\u08c1\3\2\2\2\u08c2\u08c3\3\2\2\2\u08c3\u08c4")
        buf.write("\3\2\2\2\u08c4\u08c5\7\24\2\2\u08c5\u08c6\5\u00c2b\2\u08c6")
        buf.write("\u08c8\7j\2\2\u08c7\u08c9\5\u01b0\u00d9\2\u08c8\u08c7")
        buf.write("\3\2\2\2\u08c9\u08ca\3\2\2\2\u08ca\u08c8\3\2\2\2\u08ca")
        buf.write("\u08cb\3\2\2\2\u08cb\u08cc\3\2\2\2\u08cc\u08cd\7\32\2")
        buf.write("\2\u08cd\u08cf\7\24\2\2\u08ce\u08d0\5\u00e8u\2\u08cf\u08ce")
        buf.write("\3\2\2\2\u08cf\u08d0\3\2\2\2\u08d0\u08d1\3\2\2\2\u08d1")
        buf.write("\u08d2\7\u008c\2\2\u08d2\u01b3\3\2\2\2\u08d3\u08d5\5\u0112")
        buf.write("\u008a\2\u08d4\u08d3\3\2\2\2\u08d4\u08d5\3\2\2\2\u08d5")
        buf.write("\u08d6\3\2\2\2\u08d6\u08d7\7&\2\2\u08d7\u08d8\5l\67\2")
        buf.write("\u08d8\u08d9\7j\2\2\u08d9\u08e1\5\u01ba\u00de\2\u08da")
        buf.write("\u08db\7\35\2\2\u08db\u08dc\5l\67\2\u08dc\u08dd\7j\2\2")
        buf.write("\u08dd\u08de\5\u01ba\u00de\2\u08de\u08e0\3\2\2\2\u08df")
        buf.write("\u08da\3\2\2\2\u08e0\u08e3\3\2\2\2\u08e1\u08df\3\2\2\2")
        buf.write("\u08e1\u08e2\3\2\2\2\u08e2\u08e6\3\2\2\2\u08e3\u08e1\3")
        buf.write("\2\2\2\u08e4\u08e5\7\34\2\2\u08e5\u08e7\5\u01ba\u00de")
        buf.write("\2\u08e6\u08e4\3\2\2\2\u08e6\u08e7\3\2\2\2\u08e7\u08e8")
        buf.write("\3\2\2\2\u08e8\u08e9\7\32\2\2\u08e9\u08eb\7j\2\2\u08ea")
        buf.write("\u08ec\5\u00e8u\2\u08eb\u08ea\3\2\2\2\u08eb\u08ec\3\2")
        buf.write("\2\2\u08ec\u08ed\3\2\2\2\u08ed\u08ee\7\u008c\2\2\u08ee")
        buf.write("\u01b5\3\2\2\2\u08ef\u08f1\5\u0112\u008a\2\u08f0\u08ef")
        buf.write("\3\2\2\2\u08f0\u08f1\3\2\2\2\u08f1\u08f2\3\2\2\2\u08f2")
        buf.write("\u08f4\7G\2\2\u08f3\u08f5\7+\2\2\u08f4\u08f3\3\2\2\2\u08f4")
        buf.write("\u08f5\3\2\2\2\u08f5\u08f6\3\2\2\2\u08f6\u08f7\5\u0160")
        buf.write("\u00b1\2\u08f7\u08f8\7\16\2\2\u08f8\u08f9\5\u0162\u00b2")
        buf.write("\2\u08f9\u08fa\7\32\2\2\u08fa\u08fc\7G\2\2\u08fb\u08fd")
        buf.write("\5\u00e8u\2\u08fc\u08fb\3\2\2\2\u08fc\u08fd\3\2\2\2\u08fd")
        buf.write("\u08fe\3\2\2\2\u08fe\u08ff\7\u008c\2\2\u08ff\u01b7\3\2")
        buf.write("\2\2\u0900\u090a\5\u01ae\u00d8\2\u0901\u090a\5\u01b4\u00db")
        buf.write("\2\u0902\u090a\5\u01b2\u00da\2\u0903\u090a\5\u01b6\u00dc")
        buf.write("\2\u0904\u0906\5\u0112\u008a\2\u0905\u0904\3\2\2\2\u0905")
        buf.write("\u0906\3\2\2\2\u0906\u0907\3\2\2\2\u0907\u0908\7;\2\2")
        buf.write("\u0908\u090a\7\u008c\2\2\u0909\u0900\3\2\2\2\u0909\u0901")
        buf.write("\3\2\2\2\u0909\u0902\3\2\2\2\u0909\u0903\3\2\2\2\u0909")
        buf.write("\u0905\3\2\2\2\u090a\u01b9\3\2\2\2\u090b\u090d\5\u01b8")
        buf.write("\u00dd\2\u090c\u090b\3\2\2\2\u090d\u0910\3\2\2\2\u090e")
        buf.write("\u090c\3\2\2\2\u090e\u090f\3\2\2\2\u090f\u01bb\3\2\2\2")
        buf.write("\u0910\u090e\3\2\2\2\u0911\u0912\7[\2\2\u0912\u0913\5")
        buf.write("\u01ac\u00d7\2\u0913\u0914\7\u008d\2\2\u0914\u0915\5\u01ac")
        buf.write("\u00d7\2\u0915\u0919\3\2\2\2\u0916\u0917\78\2\2\u0917")
        buf.write("\u0919\5\u01ac\u00d7\2\u0918\u0911\3\2\2\2\u0918\u0916")
        buf.write("\3\2\2\2\u0919\u01bd\3\2\2\2\u091a\u091b\7I\2\2\u091b")
        buf.write("\u091c\5\u00eav\2\u091c\u091d\7\u0093\2\2\u091d\u091e")
        buf.write("\5\u01da\u00ee\2\u091e\u091f\5\u01bc\u00df\2\u091f\u0920")
        buf.write("\7\u008c\2\2\u0920\u01bf\3\2\2\2\u0921\u0922\7.\2\2\u0922")
        buf.write("\u0923\5\u0176\u00bc\2\u0923\u0924\7m\2\2\u0924\u0925")
        buf.write("\5\u00c2b\2\u0925\u0926\7\u008c\2\2\u0926\u01c1\3\2\2")
        buf.write("\2\u0927\u0928\7^\2\2\u0928\u0929\5\u00e8u\2\u0929\u092a")
        buf.write("\7+\2\2\u092a\u092b\5\u01c4\u00e3\2\u092b\u092c\7\u008c")
        buf.write("\2\2\u092c\u01c3\3\2\2\2\u092d\u092f\5\u0126\u0094\2\u092e")
        buf.write("\u0930\5\u00eex\2\u092f\u092e\3\2\2\2\u092f\u0930\3\2")
        buf.write("\2\2\u0930\u0937\3\2\2\2\u0931\u0932\7d\2\2\u0932\u0933")
        buf.write("\5\u00c2b\2\u0933\u0934\7\5\2\2\u0934\u0935\5\u00c2b\2")
        buf.write("\u0935\u0936\7b\2\2\u0936\u0938\3\2\2\2\u0937\u0931\3")
        buf.write("\2\2\2\u0937\u0938\3\2\2\2\u0938\u01c5\3\2\2\2\u0939\u093a")
        buf.write("\5\u01d0\u00e9\2\u093a\u093b\7+\2\2\u093b\u093c\5\u01cc")
        buf.write("\u00e7\2\u093c\u093d\7\16\2\2\u093d\u093e\5\u01d6\u00ec")
        buf.write("\2\u093e\u0940\7\32\2\2\u093f\u0941\5\u01ce\u00e8\2\u0940")
        buf.write("\u093f\3\2\2\2\u0940\u0941\3\2\2\2\u0941\u0943\3\2\2\2")
        buf.write("\u0942\u0944\5\u0090I\2\u0943\u0942\3\2\2\2\u0943\u0944")
        buf.write("\3\2\2\2\u0944\u0945\3\2\2\2\u0945\u0946\7\u008c\2\2\u0946")
        buf.write("\u01c7\3\2\2\2\u0947\u0948\5\u01d0\u00e9\2\u0948\u0949")
        buf.write("\7\u008c\2\2\u0949\u01c9\3\2\2\2\u094a\u0958\5\u01c8\u00e5")
        buf.write("\2\u094b\u0958\5\u01c6\u00e4\2\u094c\u0958\5\u01ec\u00f7")
        buf.write("\2\u094d\u0958\5\u01d8\u00ed\2\u094e\u0958\5~@\2\u094f")
        buf.write("\u0958\5\u01f8\u00fd\2\u0950\u0958\5\u00c6d\2\u0951\u0958")
        buf.write("\5\22\n\2\u0952\u0958\5.\30\2\u0953\u0958\5\62\32\2\u0954")
        buf.write("\u0958\5\u01f4\u00fb\2\u0955\u0958\5\u00e4s\2\u0956\u0958")
        buf.write("\5\u00e2r\2\u0957\u094a\3\2\2\2\u0957\u094b\3\2\2\2\u0957")
        buf.write("\u094c\3\2\2\2\u0957\u094d\3\2\2\2\u0957\u094e\3\2\2\2")
        buf.write("\u0957\u094f\3\2\2\2\u0957\u0950\3\2\2\2\u0957\u0951\3")
        buf.write("\2\2\2\u0957\u0952\3\2\2\2\u0957\u0953\3\2\2\2\u0957\u0954")
        buf.write("\3\2\2\2\u0957\u0955\3\2\2\2\u0957\u0956\3\2\2\2\u0958")
        buf.write("\u01cb\3\2\2\2\u0959\u095b\5\u01ca\u00e6\2\u095a\u0959")
        buf.write("\3\2\2\2\u095b\u095e\3\2\2\2\u095c\u095a\3\2\2\2\u095c")
        buf.write("\u095d\3\2\2\2\u095d\u01cd\3\2\2\2\u095e\u095c\3\2\2\2")
        buf.write("\u095f\u0960\t\17\2\2\u0960\u01cf\3\2\2\2\u0961\u0964")
        buf.write("\5\u01d2\u00ea\2\u0962\u0964\5\u01d4\u00eb\2\u0963\u0961")
        buf.write("\3\2\2\2\u0963\u0962\3\2\2\2\u0964\u01d1\3\2\2\2\u0965")
        buf.write("\u0966\7F\2\2\u0966\u096b\5\u0090I\2\u0967\u0968\7\u008f")
        buf.write("\2\2\u0968\u0969\5\u00ceh\2\u0969\u096a\7\u0090\2\2\u096a")
        buf.write("\u096c\3\2\2\2\u096b\u0967\3\2\2\2\u096b\u096c\3\2\2\2")
        buf.write("\u096c\u01d3\3\2\2\2\u096d\u096f\t\20\2\2\u096e\u096d")
        buf.write("\3\2\2\2\u096e\u096f\3\2\2\2\u096f\u0970\3\2\2\2\u0970")
        buf.write("\u0971\7!\2\2\u0971\u0976\5\u0090I\2\u0972\u0973\7\u008f")
        buf.write("\2\2\u0973\u0974\5\u00ceh\2\u0974\u0975\7\u0090\2\2\u0975")
        buf.write("\u0977\3\2\2\2\u0976\u0972\3\2\2\2\u0976\u0977\3\2\2\2")
        buf.write("\u0977\u0978\3\2\2\2\u0978\u0979\7R\2\2\u0979\u097a\5")
        buf.write("\u01da\u00ee\2\u097a\u01d5\3\2\2\2\u097b\u097d\5\u019c")
        buf.write("\u00cf\2\u097c\u097b\3\2\2\2\u097d\u0980\3\2\2\2\u097e")
        buf.write("\u097c\3\2\2\2\u097e\u097f\3\2\2\2\u097f\u01d7\3\2\2\2")
        buf.write("\u0980\u097e\3\2\2\2\u0981\u0982\7_\2\2\u0982\u0983\5")
        buf.write("\u00e8u\2\u0983\u0984\7+\2\2\u0984\u0985\5\u01da\u00ee")
        buf.write("\2\u0985\u0986\7\u008c\2\2\u0986\u01d9\3\2\2\2\u0987\u0989")
        buf.write("\5\u012a\u0096\2\u0988\u098a\5\u012a\u0096\2\u0989\u0988")
        buf.write("\3\2\2\2\u0989\u098a\3\2\2\2\u098a\u098c\3\2\2\2\u098b")
        buf.write("\u098d\5\u0084C\2\u098c\u098b\3\2\2\2\u098c\u098d\3\2")
        buf.write("\2\2\u098d\u098f\3\2\2\2\u098e\u0990\5\u01ea\u00f6\2\u098f")
        buf.write("\u098e\3\2\2\2\u098f\u0990\3\2\2\2\u0990\u01db\3\2\2\2")
        buf.write("\u0991\u0996\5\u00e8u\2\u0992\u0996\7\u0080\2\2\u0993")
        buf.write("\u0996\7\u0081\2\2\u0994\u0996\7\b\2\2\u0995\u0991\3\2")
        buf.write("\2\2\u0995\u0992\3\2\2\2\u0995\u0993\3\2\2\2\u0995\u0994")
        buf.write("\3\2\2\2\u0996\u01dd\3\2\2\2\u0997\u099a\5\u0126\u0094")
        buf.write("\2\u0998\u099a\5\20\t\2\u0999\u0997\3\2\2\2\u0999\u0998")
        buf.write("\3\2\2\2\u099a\u01df\3\2\2\2\u099b\u09a1\5\u00c4c\2\u099c")
        buf.write("\u099d\5\u0124\u0093\2\u099d\u099e\5\u00c4c\2\u099e\u09a0")
        buf.write("\3\2\2\2\u099f\u099c\3\2\2\2\u09a0\u09a3\3\2\2\2\u09a1")
        buf.write("\u099f\3\2\2\2\u09a1\u09a2\3\2\2\2\u09a2\u01e1\3\2\2\2")
        buf.write("\u09a3\u09a1\3\2\2\2\u09a4\u09a7\5\u0126\u0094\2\u09a5")
        buf.write("\u09a6\7c\2\2\u09a6\u09a8\5\u0126\u0094\2\u09a7\u09a5")
        buf.write("\3\2\2\2\u09a7\u09a8\3\2\2\2\u09a8\u01e3\3\2\2\2\u09a9")
        buf.write("\u09aa\7`\2\2\u09aa\u09ab\5\u00eav\2\u09ab\u09ac\7\u0093")
        buf.write("\2\2\u09ac\u09ad\5\u01c4\u00e3\2\u09ad\u09ae\7\u008c\2")
        buf.write("\2\u09ae\u01e5\3\2\2\2\u09af\u09b1\5\u00eav\2\u09b0\u09b2")
        buf.write("\5\u01ea\u00f6\2\u09b1\u09b0\3\2\2\2\u09b1\u09b2\3\2\2")
        buf.write("\2\u09b2\u09b5\3\2\2\2\u09b3\u09b4\7\u0089\2\2\u09b4\u09b6")
        buf.write("\5\u00c2b\2\u09b5\u09b3\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6")
        buf.write("\u09b7\3\2\2\2\u09b7\u09b8\7b\2\2\u09b8\u01e7\3\2\2\2")
        buf.write("\u09b9\u09ba\7 \2\2\u09ba\u09bb\5\u00c2b\2\u09bb\u01e9")
        buf.write("\3\2\2\2\u09bc\u09bd\7d\2\2\u09bd\u09be\5\u00c2b\2\u09be")
        buf.write("\u01eb\3\2\2\2\u09bf\u09c0\7f\2\2\u09c0\u09c3\5\u00e8")
        buf.write("u\2\u09c1\u09c2\7+\2\2\u09c2\u09c4\5\u01ee\u00f8\2\u09c3")
        buf.write("\u09c1\3\2\2\2\u09c3\u09c4\3\2\2\2\u09c4\u09c5\3\2\2\2")
        buf.write("\u09c5\u09c6\7\u008c\2\2\u09c6\u01ed\3\2\2\2\u09c7\u09cc")
        buf.write("\5\u018c\u00c7\2\u09c8\u09cc\5b\62\2\u09c9\u09cc\5\4\3")
        buf.write("\2\u09ca\u09cc\5\u00ccg\2\u09cb\u09c7\3\2\2\2\u09cb\u09c8")
        buf.write("\3\2\2\2\u09cb\u09c9\3\2\2\2\u09cb\u09ca\3\2\2\2\u09cc")
        buf.write("\u01ef\3\2\2\2\u09cd\u09ce\7\13\2\2\u09ce\u09cf\7\u008f")
        buf.write("\2\2\u09cf\u09d4\5\u00f2z\2\u09d0\u09d1\7\u008d\2\2\u09d1")
        buf.write("\u09d3\5\u00f2z\2\u09d2\u09d0\3\2\2\2\u09d3\u09d6\3\2")
        buf.write("\2\2\u09d4\u09d2\3\2\2\2\u09d4\u09d5\3\2\2\2\u09d5\u09d7")
        buf.write("\3\2\2\2\u09d6\u09d4\3\2\2\2\u09d7\u09d8\7\u0090\2\2\u09d8")
        buf.write("\u09d9\7<\2\2\u09d9\u09da\5\u01da\u00ee\2\u09da\u01f1")
        buf.write("\3\2\2\2\u09db\u09dc\7\13\2\2\u09dc\u09dd\7\u008f\2\2")
        buf.write("\u09dd\u09e2\5\u00f2z\2\u09de\u09df\7\u008d\2\2\u09df")
        buf.write("\u09e1\5\u00f2z\2\u09e0\u09de\3\2\2\2\u09e1\u09e4\3\2")
        buf.write("\2\2\u09e2\u09e0\3\2\2\2\u09e2\u09e3\3\2\2\2\u09e3\u09e5")
        buf.write("\3\2\2\2\u09e4\u09e2\3\2\2\2\u09e5\u09e6\7\u0090\2\2\u09e6")
        buf.write("\u09e7\7<\2\2\u09e7\u09e8\5\u01c4\u00e3\2\u09e8\u01f3")
        buf.write("\3\2\2\2\u09e9\u09ea\7j\2\2\u09ea\u09ef\5\u012a\u0096")
        buf.write("\2\u09eb\u09ec\7\u008d\2\2\u09ec\u09ee\5\u012a\u0096\2")
        buf.write("\u09ed\u09eb\3\2\2\2\u09ee\u09f1\3\2\2\2\u09ef\u09ed\3")
        buf.write("\2\2\2\u09ef\u09f0\3\2\2\2\u09f0\u09f2\3\2\2\2\u09f1\u09ef")
        buf.write("\3\2\2\2\u09f2\u09f3\7\u008c\2\2\u09f3\u01f5\3\2\2\2\u09f4")
        buf.write("\u09f6\5\u0112\u008a\2\u09f5\u09f4\3\2\2\2\u09f5\u09f6")
        buf.write("\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7\u09f8\5\u01de\u00f0")
        buf.write("\2\u09f8\u09f9\7\u0089\2\2\u09f9\u09fa\5\u00c2b\2\u09fa")
        buf.write("\u09fb\7\u008c\2\2\u09fb\u01f7\3\2\2\2\u09fc\u09fe\7W")
        buf.write("\2\2\u09fd\u09fc\3\2\2\2\u09fd\u09fe\3\2\2\2\u09fe\u09ff")
        buf.write("\3\2\2\2\u09ff\u0a00\7k\2\2\u0a00\u0a01\5\u00eav\2\u0a01")
        buf.write("\u0a02\7\u0093\2\2\u0a02\u0a05\5\u01da\u00ee\2\u0a03\u0a04")
        buf.write("\7\u0089\2\2\u0a04\u0a06\5\u00c2b\2\u0a05\u0a03\3\2\2")
        buf.write("\2\u0a05\u0a06\3\2\2\2\u0a06\u0a07\3\2\2\2\u0a07\u0a08")
        buf.write("\7\u008c\2\2\u0a08\u01f9\3\2\2\2\u0a09\u0a0b\5\u0112\u008a")
        buf.write("\2\u0a0a\u0a09\3\2\2\2\u0a0a\u0a0b\3\2\2\2\u0a0b\u0a0c")
        buf.write("\3\2\2\2\u0a0c\u0a0e\7l\2\2\u0a0d\u0a0f\5\u0196\u00cc")
        buf.write("\2\u0a0e\u0a0d\3\2\2\2\u0a0e\u0a0f\3\2\2\2\u0a0f\u0a11")
        buf.write("\3\2\2\2\u0a10\u0a12\5n8\2\u0a11\u0a10\3\2\2\2\u0a11\u0a12")
        buf.write("\3\2\2\2\u0a12\u0a14\3\2\2\2\u0a13\u0a15\5\u01e8\u00f5")
        buf.write("\2\u0a14\u0a13\3\2\2\2\u0a14\u0a15\3\2\2\2\u0a15\u0a16")
        buf.write("\3\2\2\2\u0a16\u0a17\7\u008c\2\2\u0a17\u01fb\3\2\2\2\u0a18")
        buf.write("\u0a1d\5\u01fe\u0100\2\u0a19\u0a1a\7\u008d\2\2\u0a1a\u0a1c")
        buf.write("\5\u01fe\u0100\2\u0a1b\u0a19\3\2\2\2\u0a1c\u0a1f\3\2\2")
        buf.write("\2\u0a1d\u0a1b\3\2\2\2\u0a1d\u0a1e\3\2\2\2\u0a1e\u0a22")
        buf.write("\3\2\2\2\u0a1f\u0a1d\3\2\2\2\u0a20\u0a22\7g\2\2\u0a21")
        buf.write("\u0a18\3\2\2\2\u0a21\u0a20\3\2\2\2\u0a22\u01fd\3\2\2\2")
        buf.write("\u0a23\u0a26\5\u00c2b\2\u0a24\u0a25\7\6\2\2\u0a25\u0a27")
        buf.write("\5\u00c2b\2\u0a26\u0a24\3\2\2\2\u0a26\u0a27\3\2\2\2\u0a27")
        buf.write("\u01ff\3\2\2\2\u0128\u0207\u020b\u0211\u021b\u0225\u022e")
        buf.write("\u0233\u023a\u023e\u0243\u024f\u0252\u0259\u025f\u0263")
        buf.write("\u0267\u026a\u0271\u0276\u027b\u027f\u0285\u0289\u028c")
        buf.write("\u0294\u029d\u02ac\u02bb\u02be\u02c1\u02c8\u02ce\u02eb")
        buf.write("\u02f0\u02f7\u02f9\u02ff\u0301\u0308\u030b\u0313\u0316")
        buf.write("\u031f\u0326\u032b\u032e\u0334\u033f\u0347\u034b\u034f")
        buf.write("\u0354\u035c\u0361\u036e\u0375\u037d\u0380\u0389\u038c")
        buf.write("\u038f\u0394\u039b\u039e\u03a8\u03ac\u03af\u03b2\u03b8")
        buf.write("\u03bc\u03bf\u03c3\u03c8\u03cb\u03d1\u03d4\u03d8\u03ea")
        buf.write("\u03ec\u03f7\u03fa\u0401\u0406\u040b\u0418\u0428\u042d")
        buf.write("\u0432\u0437\u043a\u043f\u0449\u0455\u045a\u046d\u0472")
        buf.write("\u0478\u047f\u0489\u048d\u0490\u04a8\u04ad\u04b2\u04b5")
        buf.write("\u04b8\u04bf\u04c4\u04cd\u04d2\u04d8\u04dc\u04e4\u04ea")
        buf.write("\u04ee\u04f2\u04fc\u0502\u0508\u050f\u0517\u0528\u0530")
        buf.write("\u053a\u053e\u0543\u0549\u0551\u055e\u0569\u0570\u058e")
        buf.write("\u0592\u059f\u05a4\u05a9\u05b3\u05ba\u05c1\u05ca\u05ce")
        buf.write("\u05d5\u05da\u05dd\u05e2\u05e7\u05ef\u05fd\u0605\u060d")
        buf.write("\u0614\u0619\u061e\u0622\u0626\u062c\u0630\u0634\u063c")
        buf.write("\u0641\u0646\u064c\u0657\u065e\u0667\u066d\u0670\u0677")
        buf.write("\u0681\u0686\u068d\u0694\u069b\u06a6\u06ae\u06b8\u06bf")
        buf.write("\u06c3\u06c7\u06cd\u06d5\u06d8\u06db\u06e5\u06e8\u06f7")
        buf.write("\u06fc\u0705\u0708\u071f\u0724\u0734\u073a\u0753\u0758")
        buf.write("\u0766\u076b\u0771\u0779\u077c\u078e\u0793\u0797\u079a")
        buf.write("\u07a1\u07a4\u07ab\u07af\u07b6\u07c0\u07c5\u07cc\u07d1")
        buf.write("\u07d9\u07df\u07e8\u07ed\u07f3\u07f8\u07fe\u0803\u0809")
        buf.write("\u080e\u0812\u0820\u0824\u083e\u0849\u084f\u085e\u0864")
        buf.write("\u086a\u086f\u0874\u087e\u0882\u088d\u0892\u089a\u089d")
        buf.write("\u08a1\u08a6\u08ae\u08b2\u08b8\u08c2\u08ca\u08cf\u08d4")
        buf.write("\u08e1\u08e6\u08eb\u08f0\u08f4\u08fc\u0905\u0909\u090e")
        buf.write("\u0918\u092f\u0937\u0940\u0943\u0957\u095c\u0963\u096b")
        buf.write("\u096e\u0976\u097e\u0989\u098c\u098f\u0995\u0999\u09a1")
        buf.write("\u09a7\u09b1\u09b5\u09c3\u09cb\u09d4\u09e2\u09ef\u09f5")
        buf.write("\u09fd\u0a05\u0a0a\u0a0e\u0a11\u0a14\u0a1d\u0a21\u0a26")
        return buf.getvalue()


class vhdlParser ( Parser ):

    grammarFileName = "vhdl.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'\n'", "'\r'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'**'", "'=='", "'<='", "'>='", "'=>'", "'/='", "':='", 
                     "'<>'", "'\"'", "';'", "','", "'&'", "'('", "')'", 
                     "'['", "']'", "':'", "'*'", "'/'", "'+'", "'-'", "'<'", 
                     "'>'", "'='", "'|'", "'.'", "'\\'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'''" ]

    symbolicNames = [ "<INVALID>", "ABS", "ACCESS", "ACROSS", "AFTER", "ALIAS", 
                      "ALL", "AND", "ARCHITECTURE", "ARRAY", "ASSERT", "ATTRIBUTE", 
                      "BEGIN", "BLOCK", "BODY", "BREAK", "BUFFER", "BUS", 
                      "CASE", "COMPONENT", "CONFIGURATION", "CONSTANT", 
                      "DISCONNECT", "DOWNTO", "END", "ENTITY", "ELSE", "ELSIF", 
                      "EXIT", "FILE", "FOR", "FUNCTION", "GENERATE", "GENERIC", 
                      "GROUP", "GUARDED", "IF", "IMPURE", "IN", "INERTIAL", 
                      "INOUT", "IS", "LABEL", "LIBRARY", "LIMIT", "LINKAGE", 
                      "LITERAL", "LOOP", "MAP", "MOD", "NAND", "NATURE", 
                      "NEW", "NEXT", "NOISE", "NOR", "NOT", "NULL_", "OF", 
                      "ON", "OPEN", "OR", "OTHERS", "OUT", "PACKAGE", "PORT", 
                      "POSTPONED", "PROCESS", "PROCEDURE", "PROCEDURAL", 
                      "PURE", "QUANTITY", "RANGE", "REVERSE_RANGE", "REJECT", 
                      "REM", "RECORD", "REFERENCE", "REGISTER", "REPORT", 
                      "RETURN", "ROL", "ROR", "SELECT", "SEVERITY", "SHARED", 
                      "SIGNAL", "SLA", "SLL", "SPECTRUM", "SRA", "SRL", 
                      "SUBNATURE", "SUBTYPE", "TERMINAL", "THEN", "THROUGH", 
                      "TO", "TOLERANCE", "TRANSPORT", "TYPE", "UNAFFECTED", 
                      "UNITS", "UNTIL", "USE", "VARIABLE", "WAIT", "WITH", 
                      "WHEN", "WHILE", "XNOR", "XOR", "BASE_LITERAL", "BIT_STRING_LITERAL", 
                      "BIT_STRING_LITERAL_BINARY", "BIT_STRING_LITERAL_OCTAL", 
                      "BIT_STRING_LITERAL_HEX", "REAL_LITERAL", "BASIC_IDENTIFIER", 
                      "EXTENDED_IDENTIFIER", "LETTER", "COMMENT", "TAB", 
                      "SPACE", "NEWLINE", "CR", "CHARACTER_LITERAL", "STRING_LITERAL", 
                      "OTHER_SPECIAL_CHARACTER", "DOUBLESTAR", "ASSIGN", 
                      "LE", "GE", "ARROW", "NEQ", "VARASGN", "BOX", "DBLQUOTE", 
                      "SEMI", "COMMA", "AMPERSAND", "LPAREN", "RPAREN", 
                      "LBRACKET", "RBRACKET", "COLON", "MUL", "DIV", "PLUS", 
                      "MINUS", "LOWERTHAN", "GREATERTHAN", "EQ", "BAR", 
                      "DOT", "BACKSLASH", "EXPONENT", "HEXDIGIT", "INTEGER", 
                      "DIGIT", "BASED_INTEGER", "EXTENDED_DIGIT", "APOSTROPHE" ]

    RULE_abstract_literal = 0
    RULE_access_type_definition = 1
    RULE_across_aspect = 2
    RULE_actual_designator = 3
    RULE_actual_parameter_part = 4
    RULE_actual_part = 5
    RULE_adding_operator = 6
    RULE_aggregate = 7
    RULE_alias_declaration = 8
    RULE_alias_designator = 9
    RULE_alias_indication = 10
    RULE_allocator = 11
    RULE_architecture_body = 12
    RULE_architecture_declarative_part = 13
    RULE_architecture_statement = 14
    RULE_architecture_statement_part = 15
    RULE_array_nature_definition = 16
    RULE_array_type_definition = 17
    RULE_assertion = 18
    RULE_assertion_statement = 19
    RULE_association_element = 20
    RULE_association_list = 21
    RULE_attribute_declaration = 22
    RULE_attribute_designator = 23
    RULE_attribute_specification = 24
    RULE_base_unit_declaration = 25
    RULE_binding_indication = 26
    RULE_block_configuration = 27
    RULE_block_declarative_item = 28
    RULE_block_declarative_part = 29
    RULE_block_header = 30
    RULE_block_specification = 31
    RULE_block_statement = 32
    RULE_block_statement_part = 33
    RULE_branch_quantity_declaration = 34
    RULE_break_element = 35
    RULE_break_list = 36
    RULE_break_selector_clause = 37
    RULE_break_statement = 38
    RULE_case_statement = 39
    RULE_case_statement_alternative = 40
    RULE_choice = 41
    RULE_choices = 42
    RULE_component_configuration = 43
    RULE_component_declaration = 44
    RULE_component_instantiation_statement = 45
    RULE_component_specification = 46
    RULE_composite_nature_definition = 47
    RULE_composite_type_definition = 48
    RULE_concurrent_assertion_statement = 49
    RULE_concurrent_break_statement = 50
    RULE_concurrent_procedure_call_statement = 51
    RULE_concurrent_signal_assignment_statement = 52
    RULE_condition = 53
    RULE_condition_clause = 54
    RULE_conditional_signal_assignment = 55
    RULE_conditional_waveforms = 56
    RULE_configuration_declaration = 57
    RULE_configuration_declarative_item = 58
    RULE_configuration_declarative_part = 59
    RULE_configuration_item = 60
    RULE_configuration_specification = 61
    RULE_constant_declaration = 62
    RULE_constrained_array_definition = 63
    RULE_constrained_nature_definition = 64
    RULE_constraint = 65
    RULE_context_clause = 66
    RULE_context_item = 67
    RULE_delay_mechanism = 68
    RULE_design_file = 69
    RULE_design_unit = 70
    RULE_designator = 71
    RULE_direction = 72
    RULE_disconnection_specification = 73
    RULE_discrete_range = 74
    RULE_element_association = 75
    RULE_element_declaration = 76
    RULE_element_subnature_definition = 77
    RULE_element_subtype_definition = 78
    RULE_entity_aspect = 79
    RULE_entity_class = 80
    RULE_entity_class_entry = 81
    RULE_entity_class_entry_list = 82
    RULE_entity_declaration = 83
    RULE_entity_declarative_item = 84
    RULE_entity_declarative_part = 85
    RULE_entity_designator = 86
    RULE_entity_header = 87
    RULE_entity_name_list = 88
    RULE_entity_specification = 89
    RULE_entity_statement = 90
    RULE_entity_statement_part = 91
    RULE_entity_tag = 92
    RULE_enumeration_literal = 93
    RULE_enumeration_type_definition = 94
    RULE_exit_statement = 95
    RULE_expression = 96
    RULE_factor = 97
    RULE_file_declaration = 98
    RULE_file_logical_name = 99
    RULE_file_open_information = 100
    RULE_file_type_definition = 101
    RULE_formal_parameter_list = 102
    RULE_formal_part = 103
    RULE_free_quantity_declaration = 104
    RULE_generate_statement = 105
    RULE_generation_scheme = 106
    RULE_generic_clause = 107
    RULE_generic_list = 108
    RULE_generic_map_aspect = 109
    RULE_group_constituent = 110
    RULE_group_constituent_list = 111
    RULE_group_declaration = 112
    RULE_group_template_declaration = 113
    RULE_guarded_signal_specification = 114
    RULE_identifier = 115
    RULE_identifier_list = 116
    RULE_if_statement = 117
    RULE_index_constraint = 118
    RULE_index_specification = 119
    RULE_index_subtype_definition = 120
    RULE_instantiated_unit = 121
    RULE_instantiation_list = 122
    RULE_interface_constant_declaration = 123
    RULE_interface_declaration = 124
    RULE_interface_element = 125
    RULE_interface_file_declaration = 126
    RULE_interface_signal_list = 127
    RULE_interface_port_list = 128
    RULE_interface_list = 129
    RULE_interface_quantity_declaration = 130
    RULE_interface_port_declaration = 131
    RULE_interface_signal_declaration = 132
    RULE_interface_terminal_declaration = 133
    RULE_interface_variable_declaration = 134
    RULE_iteration_scheme = 135
    RULE_label_colon = 136
    RULE_library_clause = 137
    RULE_library_unit = 138
    RULE_literal = 139
    RULE_logical_name = 140
    RULE_logical_name_list = 141
    RULE_logical_operator = 142
    RULE_loop_statement = 143
    RULE_signal_mode = 144
    RULE_multiplying_operator = 145
    RULE_name = 146
    RULE_name_part = 147
    RULE_selected_name = 148
    RULE_selected_name_part = 149
    RULE_function_call_or_indexed_name_part = 150
    RULE_slice_name_part = 151
    RULE_attribute_name_part = 152
    RULE_nature_declaration = 153
    RULE_nature_definition = 154
    RULE_nature_element_declaration = 155
    RULE_next_statement = 156
    RULE_numeric_literal = 157
    RULE_object_declaration = 158
    RULE_opts = 159
    RULE_package_body = 160
    RULE_package_body_declarative_item = 161
    RULE_package_body_declarative_part = 162
    RULE_package_declaration = 163
    RULE_package_declarative_item = 164
    RULE_package_declarative_part = 165
    RULE_parameter_specification = 166
    RULE_physical_literal = 167
    RULE_physical_type_definition = 168
    RULE_port_clause = 169
    RULE_port_list = 170
    RULE_port_map_aspect = 171
    RULE_primary = 172
    RULE_primary_unit = 173
    RULE_procedural_declarative_item = 174
    RULE_procedural_declarative_part = 175
    RULE_procedural_statement_part = 176
    RULE_procedure_call = 177
    RULE_procedure_call_statement = 178
    RULE_process_declarative_item = 179
    RULE_process_declarative_part = 180
    RULE_process_statement = 181
    RULE_process_statement_part = 182
    RULE_qualified_expression = 183
    RULE_quantity_declaration = 184
    RULE_quantity_list = 185
    RULE_quantity_specification = 186
    RULE_range_decl = 187
    RULE_explicit_range = 188
    RULE_range_constraint = 189
    RULE_record_nature_definition = 190
    RULE_record_type_definition = 191
    RULE_relation = 192
    RULE_relational_operator = 193
    RULE_report_statement = 194
    RULE_return_statement = 195
    RULE_scalar_nature_definition = 196
    RULE_scalar_type_definition = 197
    RULE_secondary_unit = 198
    RULE_secondary_unit_declaration = 199
    RULE_selected_signal_assignment = 200
    RULE_selected_waveforms = 201
    RULE_sensitivity_clause = 202
    RULE_sensitivity_list = 203
    RULE_sequence_of_statements = 204
    RULE_sequential_statement = 205
    RULE_shift_expression = 206
    RULE_shift_operator = 207
    RULE_signal_assignment_statement = 208
    RULE_signal_declaration = 209
    RULE_signal_kind = 210
    RULE_signal_list = 211
    RULE_signature = 212
    RULE_simple_expression = 213
    RULE_simple_simultaneous_statement = 214
    RULE_simultaneous_alternative = 215
    RULE_simultaneous_case_statement = 216
    RULE_simultaneous_if_statement = 217
    RULE_simultaneous_procedural_statement = 218
    RULE_simultaneous_statement = 219
    RULE_simultaneous_statement_part = 220
    RULE_source_aspect = 221
    RULE_source_quantity_declaration = 222
    RULE_step_limit_specification = 223
    RULE_subnature_declaration = 224
    RULE_subnature_indication = 225
    RULE_subprogram_body = 226
    RULE_subprogram_declaration = 227
    RULE_subprogram_declarative_item = 228
    RULE_subprogram_declarative_part = 229
    RULE_subprogram_kind = 230
    RULE_subprogram_specification = 231
    RULE_procedure_specification = 232
    RULE_function_specification = 233
    RULE_subprogram_statement_part = 234
    RULE_subtype_declaration = 235
    RULE_subtype_indication = 236
    RULE_suffix = 237
    RULE_target = 238
    RULE_term = 239
    RULE_terminal_aspect = 240
    RULE_terminal_declaration = 241
    RULE_through_aspect = 242
    RULE_timeout_clause = 243
    RULE_tolerance_aspect = 244
    RULE_type_declaration = 245
    RULE_type_definition = 246
    RULE_unconstrained_array_definition = 247
    RULE_unconstrained_nature_definition = 248
    RULE_use_clause = 249
    RULE_variable_assignment_statement = 250
    RULE_variable_declaration = 251
    RULE_wait_statement = 252
    RULE_waveform = 253
    RULE_waveform_element = 254

    ruleNames =  [ "abstract_literal", "access_type_definition", "across_aspect", 
                   "actual_designator", "actual_parameter_part", "actual_part", 
                   "adding_operator", "aggregate", "alias_declaration", 
                   "alias_designator", "alias_indication", "allocator", 
                   "architecture_body", "architecture_declarative_part", 
                   "architecture_statement", "architecture_statement_part", 
                   "array_nature_definition", "array_type_definition", "assertion", 
                   "assertion_statement", "association_element", "association_list", 
                   "attribute_declaration", "attribute_designator", "attribute_specification", 
                   "base_unit_declaration", "binding_indication", "block_configuration", 
                   "block_declarative_item", "block_declarative_part", "block_header", 
                   "block_specification", "block_statement", "block_statement_part", 
                   "branch_quantity_declaration", "break_element", "break_list", 
                   "break_selector_clause", "break_statement", "case_statement", 
                   "case_statement_alternative", "choice", "choices", "component_configuration", 
                   "component_declaration", "component_instantiation_statement", 
                   "component_specification", "composite_nature_definition", 
                   "composite_type_definition", "concurrent_assertion_statement", 
                   "concurrent_break_statement", "concurrent_procedure_call_statement", 
                   "concurrent_signal_assignment_statement", "condition", 
                   "condition_clause", "conditional_signal_assignment", 
                   "conditional_waveforms", "configuration_declaration", 
                   "configuration_declarative_item", "configuration_declarative_part", 
                   "configuration_item", "configuration_specification", 
                   "constant_declaration", "constrained_array_definition", 
                   "constrained_nature_definition", "constraint", "context_clause", 
                   "context_item", "delay_mechanism", "design_file", "design_unit", 
                   "designator", "direction", "disconnection_specification", 
                   "discrete_range", "element_association", "element_declaration", 
                   "element_subnature_definition", "element_subtype_definition", 
                   "entity_aspect", "entity_class", "entity_class_entry", 
                   "entity_class_entry_list", "entity_declaration", "entity_declarative_item", 
                   "entity_declarative_part", "entity_designator", "entity_header", 
                   "entity_name_list", "entity_specification", "entity_statement", 
                   "entity_statement_part", "entity_tag", "enumeration_literal", 
                   "enumeration_type_definition", "exit_statement", "expression", 
                   "factor", "file_declaration", "file_logical_name", "file_open_information", 
                   "file_type_definition", "formal_parameter_list", "formal_part", 
                   "free_quantity_declaration", "generate_statement", "generation_scheme", 
                   "generic_clause", "generic_list", "generic_map_aspect", 
                   "group_constituent", "group_constituent_list", "group_declaration", 
                   "group_template_declaration", "guarded_signal_specification", 
                   "identifier", "identifier_list", "if_statement", "index_constraint", 
                   "index_specification", "index_subtype_definition", "instantiated_unit", 
                   "instantiation_list", "interface_constant_declaration", 
                   "interface_declaration", "interface_element", "interface_file_declaration", 
                   "interface_signal_list", "interface_port_list", "interface_list", 
                   "interface_quantity_declaration", "interface_port_declaration", 
                   "interface_signal_declaration", "interface_terminal_declaration", 
                   "interface_variable_declaration", "iteration_scheme", 
                   "label_colon", "library_clause", "library_unit", "literal", 
                   "logical_name", "logical_name_list", "logical_operator", 
                   "loop_statement", "signal_mode", "multiplying_operator", 
                   "name", "name_part", "selected_name", "selected_name_part", 
                   "function_call_or_indexed_name_part", "slice_name_part", 
                   "attribute_name_part", "nature_declaration", "nature_definition", 
                   "nature_element_declaration", "next_statement", "numeric_literal", 
                   "object_declaration", "opts", "package_body", "package_body_declarative_item", 
                   "package_body_declarative_part", "package_declaration", 
                   "package_declarative_item", "package_declarative_part", 
                   "parameter_specification", "physical_literal", "physical_type_definition", 
                   "port_clause", "port_list", "port_map_aspect", "primary", 
                   "primary_unit", "procedural_declarative_item", "procedural_declarative_part", 
                   "procedural_statement_part", "procedure_call", "procedure_call_statement", 
                   "process_declarative_item", "process_declarative_part", 
                   "process_statement", "process_statement_part", "qualified_expression", 
                   "quantity_declaration", "quantity_list", "quantity_specification", 
                   "range_decl", "explicit_range", "range_constraint", "record_nature_definition", 
                   "record_type_definition", "relation", "relational_operator", 
                   "report_statement", "return_statement", "scalar_nature_definition", 
                   "scalar_type_definition", "secondary_unit", "secondary_unit_declaration", 
                   "selected_signal_assignment", "selected_waveforms", "sensitivity_clause", 
                   "sensitivity_list", "sequence_of_statements", "sequential_statement", 
                   "shift_expression", "shift_operator", "signal_assignment_statement", 
                   "signal_declaration", "signal_kind", "signal_list", "signature", 
                   "simple_expression", "simple_simultaneous_statement", 
                   "simultaneous_alternative", "simultaneous_case_statement", 
                   "simultaneous_if_statement", "simultaneous_procedural_statement", 
                   "simultaneous_statement", "simultaneous_statement_part", 
                   "source_aspect", "source_quantity_declaration", "step_limit_specification", 
                   "subnature_declaration", "subnature_indication", "subprogram_body", 
                   "subprogram_declaration", "subprogram_declarative_item", 
                   "subprogram_declarative_part", "subprogram_kind", "subprogram_specification", 
                   "procedure_specification", "function_specification", 
                   "subprogram_statement_part", "subtype_declaration", "subtype_indication", 
                   "suffix", "target", "term", "terminal_aspect", "terminal_declaration", 
                   "through_aspect", "timeout_clause", "tolerance_aspect", 
                   "type_declaration", "type_definition", "unconstrained_array_definition", 
                   "unconstrained_nature_definition", "use_clause", "variable_assignment_statement", 
                   "variable_declaration", "wait_statement", "waveform", 
                   "waveform_element" ]

    EOF = Token.EOF
    ABS=1
    ACCESS=2
    ACROSS=3
    AFTER=4
    ALIAS=5
    ALL=6
    AND=7
    ARCHITECTURE=8
    ARRAY=9
    ASSERT=10
    ATTRIBUTE=11
    BEGIN=12
    BLOCK=13
    BODY=14
    BREAK=15
    BUFFER=16
    BUS=17
    CASE=18
    COMPONENT=19
    CONFIGURATION=20
    CONSTANT=21
    DISCONNECT=22
    DOWNTO=23
    END=24
    ENTITY=25
    ELSE=26
    ELSIF=27
    EXIT=28
    FILE=29
    FOR=30
    FUNCTION=31
    GENERATE=32
    GENERIC=33
    GROUP=34
    GUARDED=35
    IF=36
    IMPURE=37
    IN=38
    INERTIAL=39
    INOUT=40
    IS=41
    LABEL=42
    LIBRARY=43
    LIMIT=44
    LINKAGE=45
    LITERAL=46
    LOOP=47
    MAP=48
    MOD=49
    NAND=50
    NATURE=51
    NEW=52
    NEXT=53
    NOISE=54
    NOR=55
    NOT=56
    NULL_=57
    OF=58
    ON=59
    OPEN=60
    OR=61
    OTHERS=62
    OUT=63
    PACKAGE=64
    PORT=65
    POSTPONED=66
    PROCESS=67
    PROCEDURE=68
    PROCEDURAL=69
    PURE=70
    QUANTITY=71
    RANGE=72
    REVERSE_RANGE=73
    REJECT=74
    REM=75
    RECORD=76
    REFERENCE=77
    REGISTER=78
    REPORT=79
    RETURN=80
    ROL=81
    ROR=82
    SELECT=83
    SEVERITY=84
    SHARED=85
    SIGNAL=86
    SLA=87
    SLL=88
    SPECTRUM=89
    SRA=90
    SRL=91
    SUBNATURE=92
    SUBTYPE=93
    TERMINAL=94
    THEN=95
    THROUGH=96
    TO=97
    TOLERANCE=98
    TRANSPORT=99
    TYPE=100
    UNAFFECTED=101
    UNITS=102
    UNTIL=103
    USE=104
    VARIABLE=105
    WAIT=106
    WITH=107
    WHEN=108
    WHILE=109
    XNOR=110
    XOR=111
    BASE_LITERAL=112
    BIT_STRING_LITERAL=113
    BIT_STRING_LITERAL_BINARY=114
    BIT_STRING_LITERAL_OCTAL=115
    BIT_STRING_LITERAL_HEX=116
    REAL_LITERAL=117
    BASIC_IDENTIFIER=118
    EXTENDED_IDENTIFIER=119
    LETTER=120
    COMMENT=121
    TAB=122
    SPACE=123
    NEWLINE=124
    CR=125
    CHARACTER_LITERAL=126
    STRING_LITERAL=127
    OTHER_SPECIAL_CHARACTER=128
    DOUBLESTAR=129
    ASSIGN=130
    LE=131
    GE=132
    ARROW=133
    NEQ=134
    VARASGN=135
    BOX=136
    DBLQUOTE=137
    SEMI=138
    COMMA=139
    AMPERSAND=140
    LPAREN=141
    RPAREN=142
    LBRACKET=143
    RBRACKET=144
    COLON=145
    MUL=146
    DIV=147
    PLUS=148
    MINUS=149
    LOWERTHAN=150
    GREATERTHAN=151
    EQ=152
    BAR=153
    DOT=154
    BACKSLASH=155
    EXPONENT=156
    HEXDIGIT=157
    INTEGER=158
    DIGIT=159
    BASED_INTEGER=160
    EXTENDED_DIGIT=161
    APOSTROPHE=162

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




    class Abstract_literalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INTEGER(self):
            return self.getToken(vhdlParser.INTEGER, 0)

        def REAL_LITERAL(self):
            return self.getToken(vhdlParser.REAL_LITERAL, 0)

        def BASE_LITERAL(self):
            return self.getToken(vhdlParser.BASE_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_abstract_literal

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

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

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




    def abstract_literal(self):

        localctx = vhdlParser.Abstract_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_abstract_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 510
            _la = self._input.LA(1)
            if not(((((_la - 112)) & ~0x3f) == 0 and ((1 << (_la - 112)) & ((1 << (vhdlParser.BASE_LITERAL - 112)) | (1 << (vhdlParser.REAL_LITERAL - 112)) | (1 << (vhdlParser.INTEGER - 112)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Access_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ACCESS(self):
            return self.getToken(vhdlParser.ACCESS, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_access_type_definition

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

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

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




    def access_type_definition(self):

        localctx = vhdlParser.Access_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_access_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 512
            self.match(vhdlParser.ACCESS)
            self.state = 513
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Across_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def ACROSS(self):
            return self.getToken(vhdlParser.ACROSS, 0)

        def tolerance_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Tolerance_aspectContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_across_aspect

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

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

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




    def across_aspect(self):

        localctx = vhdlParser.Across_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_across_aspect)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 515
            self.identifier_list()
            self.state = 517
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.TOLERANCE:
                self.state = 516
                self.tolerance_aspect()


            self.state = 521
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 519
                self.match(vhdlParser.VARASGN)
                self.state = 520
                self.expression()


            self.state = 523
            self.match(vhdlParser.ACROSS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Actual_designatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def OPEN(self):
            return self.getToken(vhdlParser.OPEN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_actual_designator

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

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

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




    def actual_designator(self):

        localctx = vhdlParser.Actual_designatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_actual_designator)
        try:
            self.state = 527
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ABS, vhdlParser.NEW, vhdlParser.NOT, vhdlParser.NULL_, vhdlParser.BASE_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.REAL_LITERAL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.PLUS, vhdlParser.MINUS, vhdlParser.INTEGER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 525
                self.expression()
                pass
            elif token in [vhdlParser.OPEN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 526
                self.match(vhdlParser.OPEN)
                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 Actual_parameter_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def association_list(self):
            return self.getTypedRuleContext(vhdlParser.Association_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_actual_parameter_part

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

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

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




    def actual_parameter_part(self):

        localctx = vhdlParser.Actual_parameter_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_actual_parameter_part)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 529
            self.association_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Actual_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def actual_designator(self):
            return self.getTypedRuleContext(vhdlParser.Actual_designatorContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_actual_part

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

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

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




    def actual_part(self):

        localctx = vhdlParser.Actual_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_actual_part)
        try:
            self.state = 537
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 531
                self.name()
                self.state = 532
                self.match(vhdlParser.LPAREN)
                self.state = 533
                self.actual_designator()
                self.state = 534
                self.match(vhdlParser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 536
                self.actual_designator()
                pass


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


    class Adding_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PLUS(self):
            return self.getToken(vhdlParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(vhdlParser.MINUS, 0)

        def AMPERSAND(self):
            return self.getToken(vhdlParser.AMPERSAND, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_adding_operator

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

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

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




    def adding_operator(self):

        localctx = vhdlParser.Adding_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_adding_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            _la = self._input.LA(1)
            if not(((((_la - 140)) & ~0x3f) == 0 and ((1 << (_la - 140)) & ((1 << (vhdlParser.AMPERSAND - 140)) | (1 << (vhdlParser.PLUS - 140)) | (1 << (vhdlParser.MINUS - 140)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AggregateContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def element_association(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Element_associationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Element_associationContext,i)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

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

        def getRuleIndex(self):
            return vhdlParser.RULE_aggregate

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

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

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




    def aggregate(self):

        localctx = vhdlParser.AggregateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_aggregate)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            self.match(vhdlParser.LPAREN)
            self.state = 542
            self.element_association()
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 543
                self.match(vhdlParser.COMMA)
                self.state = 544
                self.element_association()
                self.state = 549
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 550
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Alias_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALIAS(self):
            return self.getToken(vhdlParser.ALIAS, 0)

        def alias_designator(self):
            return self.getTypedRuleContext(vhdlParser.Alias_designatorContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

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


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def alias_indication(self):
            return self.getTypedRuleContext(vhdlParser.Alias_indicationContext,0)


        def signature(self):
            return self.getTypedRuleContext(vhdlParser.SignatureContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_alias_declaration

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

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

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




    def alias_declaration(self):

        localctx = vhdlParser.Alias_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_alias_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            self.match(vhdlParser.ALIAS)
            self.state = 553
            self.alias_designator()
            self.state = 556
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.COLON:
                self.state = 554
                self.match(vhdlParser.COLON)
                self.state = 555
                self.alias_indication()


            self.state = 558
            self.match(vhdlParser.IS)
            self.state = 559
            self.name()
            self.state = 561
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LBRACKET:
                self.state = 560
                self.signature()


            self.state = 563
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Alias_designatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def CHARACTER_LITERAL(self):
            return self.getToken(vhdlParser.CHARACTER_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_alias_designator

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

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

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




    def alias_designator(self):

        localctx = vhdlParser.Alias_designatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_alias_designator)
        try:
            self.state = 568
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 565
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 566
                self.match(vhdlParser.CHARACTER_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 567
                self.match(vhdlParser.STRING_LITERAL)
                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 Alias_indicationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_alias_indication

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

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

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




    def alias_indication(self):

        localctx = vhdlParser.Alias_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_alias_indication)
        try:
            self.state = 572
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 570
                self.subnature_indication()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 571
                self.subtype_indication()
                pass


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


    class AllocatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NEW(self):
            return self.getToken(vhdlParser.NEW, 0)

        def qualified_expression(self):
            return self.getTypedRuleContext(vhdlParser.Qualified_expressionContext,0)


        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_allocator

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

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

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




    def allocator(self):

        localctx = vhdlParser.AllocatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_allocator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 574
            self.match(vhdlParser.NEW)
            self.state = 577
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 575
                self.qualified_expression()
                pass

            elif la_ == 2:
                self.state = 576
                self.subtype_indication()
                pass


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


    class Architecture_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def architecture_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Architecture_declarative_partContext,0)


        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def architecture_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Architecture_statement_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_architecture_body

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

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

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




    def architecture_body(self):

        localctx = vhdlParser.Architecture_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_architecture_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 579
            self.match(vhdlParser.ARCHITECTURE)
            self.state = 580
            self.identifier()
            self.state = 581
            self.match(vhdlParser.OF)
            self.state = 582
            self.identifier()
            self.state = 583
            self.match(vhdlParser.IS)
            self.state = 584
            self.architecture_declarative_part()
            self.state = 585
            self.match(vhdlParser.BEGIN)
            self.state = 586
            self.architecture_statement_part()
            self.state = 587
            self.match(vhdlParser.END)
            self.state = 589
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ARCHITECTURE:
                self.state = 588
                self.match(vhdlParser.ARCHITECTURE)


            self.state = 592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 591
                self.identifier()


            self.state = 594
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Architecture_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Block_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Block_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_architecture_declarative_part

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

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

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




    def architecture_declarative_part(self):

        localctx = vhdlParser.Architecture_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_architecture_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FOR) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.LIMIT) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.QUANTITY - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 596
                self.block_declarative_item()
                self.state = 601
                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 Architecture_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block_statement(self):
            return self.getTypedRuleContext(vhdlParser.Block_statementContext,0)


        def process_statement(self):
            return self.getTypedRuleContext(vhdlParser.Process_statementContext,0)


        def concurrent_procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_procedure_call_statementContext,0)


        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def concurrent_assertion_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_assertion_statementContext,0)


        def concurrent_signal_assignment_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_signal_assignment_statementContext,0)


        def POSTPONED(self):
            return self.getToken(vhdlParser.POSTPONED, 0)

        def component_instantiation_statement(self):
            return self.getTypedRuleContext(vhdlParser.Component_instantiation_statementContext,0)


        def generate_statement(self):
            return self.getTypedRuleContext(vhdlParser.Generate_statementContext,0)


        def concurrent_break_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_break_statementContext,0)


        def simultaneous_statement(self):
            return self.getTypedRuleContext(vhdlParser.Simultaneous_statementContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_architecture_statement

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

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

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




    def architecture_statement(self):

        localctx = vhdlParser.Architecture_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_architecture_statement)
        try:
            self.state = 623
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 602
                self.block_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 603
                self.process_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 605
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                if la_ == 1:
                    self.state = 604
                    self.label_colon()


                self.state = 607
                self.concurrent_procedure_call_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 609
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                if la_ == 1:
                    self.state = 608
                    self.label_colon()


                self.state = 611
                self.concurrent_assertion_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 613
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                if la_ == 1:
                    self.state = 612
                    self.label_colon()


                self.state = 616
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                if la_ == 1:
                    self.state = 615
                    self.match(vhdlParser.POSTPONED)


                self.state = 618
                self.concurrent_signal_assignment_statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 619
                self.component_instantiation_statement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 620
                self.generate_statement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 621
                self.concurrent_break_statement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 622
                self.simultaneous_statement()
                pass


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


    class Architecture_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def architecture_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Architecture_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Architecture_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_architecture_statement_part

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

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

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




    def architecture_statement_part(self):

        localctx = vhdlParser.Architecture_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_architecture_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ABS) | (1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.IF) | (1 << vhdlParser.NEW) | (1 << vhdlParser.NOT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (vhdlParser.POSTPONED - 66)) | (1 << (vhdlParser.PROCESS - 66)) | (1 << (vhdlParser.PROCEDURAL - 66)) | (1 << (vhdlParser.WITH - 66)) | (1 << (vhdlParser.BASE_LITERAL - 66)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 66)) | (1 << (vhdlParser.REAL_LITERAL - 66)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 66)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 66)) | (1 << (vhdlParser.CHARACTER_LITERAL - 66)) | (1 << (vhdlParser.STRING_LITERAL - 66)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (vhdlParser.LPAREN - 141)) | (1 << (vhdlParser.PLUS - 141)) | (1 << (vhdlParser.MINUS - 141)) | (1 << (vhdlParser.INTEGER - 141)))) != 0):
                self.state = 625
                self.architecture_statement()
                self.state = 630
                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 Array_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unconstrained_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Unconstrained_nature_definitionContext,0)


        def constrained_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Constrained_nature_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_array_nature_definition

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

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

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




    def array_nature_definition(self):

        localctx = vhdlParser.Array_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_array_nature_definition)
        try:
            self.state = 633
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 631
                self.unconstrained_nature_definition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 632
                self.constrained_nature_definition()
                pass


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


    class Array_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unconstrained_array_definition(self):
            return self.getTypedRuleContext(vhdlParser.Unconstrained_array_definitionContext,0)


        def constrained_array_definition(self):
            return self.getTypedRuleContext(vhdlParser.Constrained_array_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_array_type_definition

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

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

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




    def array_type_definition(self):

        localctx = vhdlParser.Array_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_array_type_definition)
        try:
            self.state = 637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 635
                self.unconstrained_array_definition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 636
                self.constrained_array_definition()
                pass


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


    class AssertionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ASSERT(self):
            return self.getToken(vhdlParser.ASSERT, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def REPORT(self):
            return self.getToken(vhdlParser.REPORT, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ExpressionContext,i)


        def SEVERITY(self):
            return self.getToken(vhdlParser.SEVERITY, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_assertion

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

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

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




    def assertion(self):

        localctx = vhdlParser.AssertionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_assertion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.match(vhdlParser.ASSERT)
            self.state = 640
            self.condition()
            self.state = 643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.REPORT:
                self.state = 641
                self.match(vhdlParser.REPORT)
                self.state = 642
                self.expression()


            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.SEVERITY:
                self.state = 645
                self.match(vhdlParser.SEVERITY)
                self.state = 646
                self.expression()


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


    class Assertion_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assertion(self):
            return self.getTypedRuleContext(vhdlParser.AssertionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_assertion_statement

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

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

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




    def assertion_statement(self):

        localctx = vhdlParser.Assertion_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_assertion_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 650
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 649
                self.label_colon()


            self.state = 652
            self.assertion()
            self.state = 653
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Association_elementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def actual_part(self):
            return self.getTypedRuleContext(vhdlParser.Actual_partContext,0)


        def formal_part(self):
            return self.getTypedRuleContext(vhdlParser.Formal_partContext,0)


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_association_element

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

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

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




    def association_element(self):

        localctx = vhdlParser.Association_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_association_element)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 655
                self.formal_part()
                self.state = 656
                self.match(vhdlParser.ARROW)


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


    class Association_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def association_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Association_elementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Association_elementContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_association_list

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

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

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




    def association_list(self):

        localctx = vhdlParser.Association_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_association_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 662
            self.association_element()
            self.state = 667
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 663
                self.match(vhdlParser.COMMA)
                self.state = 664
                self.association_element()
                self.state = 669
                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 Attribute_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ATTRIBUTE(self):
            return self.getToken(vhdlParser.ATTRIBUTE, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


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


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_attribute_declaration

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

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

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




    def attribute_declaration(self):

        localctx = vhdlParser.Attribute_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_attribute_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 670
            self.match(vhdlParser.ATTRIBUTE)
            self.state = 671
            self.label_colon()
            self.state = 672
            self.name()
            self.state = 673
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_designatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def RANGE(self):
            return self.getToken(vhdlParser.RANGE, 0)

        def REVERSE_RANGE(self):
            return self.getToken(vhdlParser.REVERSE_RANGE, 0)

        def ACROSS(self):
            return self.getToken(vhdlParser.ACROSS, 0)

        def THROUGH(self):
            return self.getToken(vhdlParser.THROUGH, 0)

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

        def TOLERANCE(self):
            return self.getToken(vhdlParser.TOLERANCE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_attribute_designator

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

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

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




    def attribute_designator(self):

        localctx = vhdlParser.Attribute_designatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_attribute_designator)
        try:
            self.state = 682
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 675
                self.identifier()
                pass
            elif token in [vhdlParser.RANGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 676
                self.match(vhdlParser.RANGE)
                pass
            elif token in [vhdlParser.REVERSE_RANGE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 677
                self.match(vhdlParser.REVERSE_RANGE)
                pass
            elif token in [vhdlParser.ACROSS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 678
                self.match(vhdlParser.ACROSS)
                pass
            elif token in [vhdlParser.THROUGH]:
                self.enterOuterAlt(localctx, 5)
                self.state = 679
                self.match(vhdlParser.THROUGH)
                pass
            elif token in [vhdlParser.REFERENCE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 680
                self.match(vhdlParser.REFERENCE)
                pass
            elif token in [vhdlParser.TOLERANCE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 681
                self.match(vhdlParser.TOLERANCE)
                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 Attribute_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ATTRIBUTE(self):
            return self.getToken(vhdlParser.ATTRIBUTE, 0)

        def attribute_designator(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_designatorContext,0)


        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def entity_specification(self):
            return self.getTypedRuleContext(vhdlParser.Entity_specificationContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_attribute_specification

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

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

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




    def attribute_specification(self):

        localctx = vhdlParser.Attribute_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_attribute_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 684
            self.match(vhdlParser.ATTRIBUTE)
            self.state = 685
            self.attribute_designator()
            self.state = 686
            self.match(vhdlParser.OF)
            self.state = 687
            self.entity_specification()
            self.state = 688
            self.match(vhdlParser.IS)
            self.state = 689
            self.expression()
            self.state = 690
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Base_unit_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_base_unit_declaration

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

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

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




    def base_unit_declaration(self):

        localctx = vhdlParser.Base_unit_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_base_unit_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 692
            self.identifier()
            self.state = 693
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Binding_indicationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def USE(self):
            return self.getToken(vhdlParser.USE, 0)

        def entity_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Entity_aspectContext,0)


        def generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Generic_map_aspectContext,0)


        def port_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Port_map_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_binding_indication

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

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

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




    def binding_indication(self):

        localctx = vhdlParser.Binding_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_binding_indication)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.USE:
                self.state = 695
                self.match(vhdlParser.USE)
                self.state = 696
                self.entity_aspect()


            self.state = 700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC:
                self.state = 699
                self.generic_map_aspect()


            self.state = 703
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PORT:
                self.state = 702
                self.port_map_aspect()


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


    class Block_configurationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def block_specification(self):
            return self.getTypedRuleContext(vhdlParser.Block_specificationContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def use_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Use_clauseContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Use_clauseContext,i)


        def configuration_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Configuration_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Configuration_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_configuration

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

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

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




    def block_configuration(self):

        localctx = vhdlParser.Block_configurationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_block_configuration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 705
            self.match(vhdlParser.FOR)
            self.state = 706
            self.block_specification()
            self.state = 710
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.USE:
                self.state = 707
                self.use_clause()
                self.state = 712
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 716
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.FOR:
                self.state = 713
                self.configuration_item()
                self.state = 718
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 719
            self.match(vhdlParser.END)
            self.state = 720
            self.match(vhdlParser.FOR)
            self.state = 721
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Block_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def signal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Signal_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def component_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Component_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def configuration_specification(self):
            return self.getTypedRuleContext(vhdlParser.Configuration_specificationContext,0)


        def disconnection_specification(self):
            return self.getTypedRuleContext(vhdlParser.Disconnection_specificationContext,0)


        def step_limit_specification(self):
            return self.getTypedRuleContext(vhdlParser.Step_limit_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def nature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Nature_declarationContext,0)


        def subnature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_declarationContext,0)


        def quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Quantity_declarationContext,0)


        def terminal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Terminal_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_declarative_item

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

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

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




    def block_declarative_item(self):

        localctx = vhdlParser.Block_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_block_declarative_item)
        try:
            self.state = 745
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 723
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 724
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 725
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 726
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 727
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 728
                self.signal_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 729
                self.variable_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 730
                self.file_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 731
                self.alias_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 732
                self.component_declaration()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 733
                self.attribute_declaration()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 734
                self.attribute_specification()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 735
                self.configuration_specification()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 736
                self.disconnection_specification()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 737
                self.step_limit_specification()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 738
                self.use_clause()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 739
                self.group_template_declaration()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 740
                self.group_declaration()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 741
                self.nature_declaration()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 742
                self.subnature_declaration()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 743
                self.quantity_declaration()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 744
                self.terminal_declaration()
                pass


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


    class Block_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Block_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Block_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_declarative_part

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

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

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




    def block_declarative_part(self):

        localctx = vhdlParser.Block_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_block_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 750
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FOR) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.LIMIT) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.QUANTITY - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 747
                self.block_declarative_item()
                self.state = 752
                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 Block_headerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def generic_clause(self):
            return self.getTypedRuleContext(vhdlParser.Generic_clauseContext,0)


        def port_clause(self):
            return self.getTypedRuleContext(vhdlParser.Port_clauseContext,0)


        def generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Generic_map_aspectContext,0)


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

        def port_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Port_map_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_header

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

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

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




    def block_header(self):

        localctx = vhdlParser.Block_headerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_block_header)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 759
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC:
                self.state = 753
                self.generic_clause()
                self.state = 757
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.GENERIC:
                    self.state = 754
                    self.generic_map_aspect()
                    self.state = 755
                    self.match(vhdlParser.SEMI)




            self.state = 767
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PORT:
                self.state = 761
                self.port_clause()
                self.state = 765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.PORT:
                    self.state = 762
                    self.port_map_aspect()
                    self.state = 763
                    self.match(vhdlParser.SEMI)




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


    class Block_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def index_specification(self):
            return self.getTypedRuleContext(vhdlParser.Index_specificationContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

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


        def getRuleIndex(self):
            return vhdlParser.RULE_block_specification

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

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

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




    def block_specification(self):

        localctx = vhdlParser.Block_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_block_specification)
        self._la = 0 # Token type
        try:
            self.state = 777
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 769
                self.identifier()
                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.LPAREN:
                    self.state = 770
                    self.match(vhdlParser.LPAREN)
                    self.state = 771
                    self.index_specification()
                    self.state = 772
                    self.match(vhdlParser.RPAREN)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 776
                self.name()
                pass


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


    class Block_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


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

        def block_header(self):
            return self.getTypedRuleContext(vhdlParser.Block_headerContext,0)


        def block_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Block_declarative_partContext,0)


        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def block_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Block_statement_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_statement

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

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

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




    def block_statement(self):

        localctx = vhdlParser.Block_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_block_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self.label_colon()
            self.state = 780
            self.match(vhdlParser.BLOCK)
            self.state = 785
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 781
                self.match(vhdlParser.LPAREN)
                self.state = 782
                self.expression()
                self.state = 783
                self.match(vhdlParser.RPAREN)


            self.state = 788
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS:
                self.state = 787
                self.match(vhdlParser.IS)


            self.state = 790
            self.block_header()
            self.state = 791
            self.block_declarative_part()
            self.state = 792
            self.match(vhdlParser.BEGIN)
            self.state = 793
            self.block_statement_part()
            self.state = 794
            self.match(vhdlParser.END)
            self.state = 795
            self.match(vhdlParser.BLOCK)
            self.state = 797
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 796
                self.identifier()


            self.state = 799
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Block_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def architecture_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Architecture_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Architecture_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_block_statement_part

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

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

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




    def block_statement_part(self):

        localctx = vhdlParser.Block_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_block_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 804
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ABS) | (1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.IF) | (1 << vhdlParser.NEW) | (1 << vhdlParser.NOT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (vhdlParser.POSTPONED - 66)) | (1 << (vhdlParser.PROCESS - 66)) | (1 << (vhdlParser.PROCEDURAL - 66)) | (1 << (vhdlParser.WITH - 66)) | (1 << (vhdlParser.BASE_LITERAL - 66)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 66)) | (1 << (vhdlParser.REAL_LITERAL - 66)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 66)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 66)) | (1 << (vhdlParser.CHARACTER_LITERAL - 66)) | (1 << (vhdlParser.STRING_LITERAL - 66)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (vhdlParser.LPAREN - 141)) | (1 << (vhdlParser.PLUS - 141)) | (1 << (vhdlParser.MINUS - 141)) | (1 << (vhdlParser.INTEGER - 141)))) != 0):
                self.state = 801
                self.architecture_statement()
                self.state = 806
                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 Branch_quantity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QUANTITY(self):
            return self.getToken(vhdlParser.QUANTITY, 0)

        def terminal_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Terminal_aspectContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def across_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Across_aspectContext,0)


        def through_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Through_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_branch_quantity_declaration

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

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

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




    def branch_quantity_declaration(self):

        localctx = vhdlParser.Branch_quantity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_branch_quantity_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 807
            self.match(vhdlParser.QUANTITY)
            self.state = 809
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 808
                self.across_aspect()


            self.state = 812
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.state = 811
                self.through_aspect()


            self.state = 814
            self.terminal_aspect()
            self.state = 815
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Break_elementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def break_selector_clause(self):
            return self.getTypedRuleContext(vhdlParser.Break_selector_clauseContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_break_element

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

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

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




    def break_element(self):

        localctx = vhdlParser.Break_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_break_element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR:
                self.state = 817
                self.break_selector_clause()


            self.state = 820
            self.name()
            self.state = 821
            self.match(vhdlParser.ARROW)
            self.state = 822
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Break_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def break_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Break_elementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Break_elementContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_break_list

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

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

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




    def break_list(self):

        localctx = vhdlParser.Break_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_break_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 824
            self.break_element()
            self.state = 829
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 825
                self.match(vhdlParser.COMMA)
                self.state = 826
                self.break_element()
                self.state = 831
                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 Break_selector_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(vhdlParser.FOR, 0)

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


        def USE(self):
            return self.getToken(vhdlParser.USE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_break_selector_clause

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

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

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




    def break_selector_clause(self):

        localctx = vhdlParser.Break_selector_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_break_selector_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 832
            self.match(vhdlParser.FOR)
            self.state = 833
            self.name()
            self.state = 834
            self.match(vhdlParser.USE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Break_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BREAK(self):
            return self.getToken(vhdlParser.BREAK, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def break_list(self):
            return self.getTypedRuleContext(vhdlParser.Break_listContext,0)


        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_break_statement

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

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

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




    def break_statement(self):

        localctx = vhdlParser.Break_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_break_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 837
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 836
                self.label_colon()


            self.state = 839
            self.match(vhdlParser.BREAK)
            self.state = 841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR or ((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 118)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 118)) | (1 << (vhdlParser.STRING_LITERAL - 118)))) != 0):
                self.state = 840
                self.break_list()


            self.state = 845
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.WHEN:
                self.state = 843
                self.match(vhdlParser.WHEN)
                self.state = 844
                self.condition()


            self.state = 847
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Case_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def case_statement_alternative(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Case_statement_alternativeContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Case_statement_alternativeContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_case_statement

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

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

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




    def case_statement(self):

        localctx = vhdlParser.Case_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_case_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 850
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 849
                self.label_colon()


            self.state = 852
            self.match(vhdlParser.CASE)
            self.state = 853
            self.expression()
            self.state = 854
            self.match(vhdlParser.IS)
            self.state = 856 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 855
                self.case_statement_alternative()
                self.state = 858 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.WHEN):
                    break

            self.state = 860
            self.match(vhdlParser.END)
            self.state = 861
            self.match(vhdlParser.CASE)
            self.state = 863
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 862
                self.identifier()


            self.state = 865
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Case_statement_alternativeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def choices(self):
            return self.getTypedRuleContext(vhdlParser.ChoicesContext,0)


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def sequence_of_statements(self):
            return self.getTypedRuleContext(vhdlParser.Sequence_of_statementsContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_case_statement_alternative

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

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

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




    def case_statement_alternative(self):

        localctx = vhdlParser.Case_statement_alternativeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_case_statement_alternative)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.match(vhdlParser.WHEN)
            self.state = 868
            self.choices()
            self.state = 869
            self.match(vhdlParser.ARROW)
            self.state = 870
            self.sequence_of_statements()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ChoiceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def discrete_range(self):
            return self.getTypedRuleContext(vhdlParser.Discrete_rangeContext,0)


        def simple_expression(self):
            return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,0)


        def OTHERS(self):
            return self.getToken(vhdlParser.OTHERS, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_choice

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

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

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




    def choice(self):

        localctx = vhdlParser.ChoiceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_choice)
        try:
            self.state = 876
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 872
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 873
                self.discrete_range()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 874
                self.simple_expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 875
                self.match(vhdlParser.OTHERS)
                pass


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


    class ChoicesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def choice(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ChoiceContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ChoiceContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_choices

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

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

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




    def choices(self):

        localctx = vhdlParser.ChoicesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_choices)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 878
            self.choice()
            self.state = 883
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.BAR:
                self.state = 879
                self.match(vhdlParser.BAR)
                self.state = 880
                self.choice()
                self.state = 885
                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 Component_configurationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def component_specification(self):
            return self.getTypedRuleContext(vhdlParser.Component_specificationContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

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

        def binding_indication(self):
            return self.getTypedRuleContext(vhdlParser.Binding_indicationContext,0)


        def block_configuration(self):
            return self.getTypedRuleContext(vhdlParser.Block_configurationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_component_configuration

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

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

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




    def component_configuration(self):

        localctx = vhdlParser.Component_configurationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_component_configuration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 886
            self.match(vhdlParser.FOR)
            self.state = 887
            self.component_specification()
            self.state = 891
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC or _la==vhdlParser.PORT or _la==vhdlParser.USE or _la==vhdlParser.SEMI:
                self.state = 888
                self.binding_indication()
                self.state = 889
                self.match(vhdlParser.SEMI)


            self.state = 894
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR:
                self.state = 893
                self.block_configuration()


            self.state = 896
            self.match(vhdlParser.END)
            self.state = 897
            self.match(vhdlParser.FOR)
            self.state = 898
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def generic_clause(self):
            return self.getTypedRuleContext(vhdlParser.Generic_clauseContext,0)


        def port_clause(self):
            return self.getTypedRuleContext(vhdlParser.Port_clauseContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_component_declaration

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

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

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




    def component_declaration(self):

        localctx = vhdlParser.Component_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_component_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 900
            self.match(vhdlParser.COMPONENT)
            self.state = 901
            self.identifier()
            self.state = 903
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS:
                self.state = 902
                self.match(vhdlParser.IS)


            self.state = 906
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC:
                self.state = 905
                self.generic_clause()


            self.state = 909
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PORT:
                self.state = 908
                self.port_clause()


            self.state = 911
            self.match(vhdlParser.END)
            self.state = 912
            self.match(vhdlParser.COMPONENT)
            self.state = 914
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 913
                self.identifier()


            self.state = 916
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_instantiation_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def instantiated_unit(self):
            return self.getTypedRuleContext(vhdlParser.Instantiated_unitContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Generic_map_aspectContext,0)


        def port_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Port_map_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_component_instantiation_statement

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

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

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




    def component_instantiation_statement(self):

        localctx = vhdlParser.Component_instantiation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_component_instantiation_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            self.label_colon()
            self.state = 919
            self.instantiated_unit()
            self.state = 921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC:
                self.state = 920
                self.generic_map_aspect()


            self.state = 924
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PORT:
                self.state = 923
                self.port_map_aspect()


            self.state = 926
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def instantiation_list(self):
            return self.getTypedRuleContext(vhdlParser.Instantiation_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

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


        def getRuleIndex(self):
            return vhdlParser.RULE_component_specification

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

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

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




    def component_specification(self):

        localctx = vhdlParser.Component_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_component_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 928
            self.instantiation_list()
            self.state = 929
            self.match(vhdlParser.COLON)
            self.state = 930
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Composite_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def array_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Array_nature_definitionContext,0)


        def record_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Record_nature_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_composite_nature_definition

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

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

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




    def composite_nature_definition(self):

        localctx = vhdlParser.Composite_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_composite_nature_definition)
        try:
            self.state = 934
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ARRAY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 932
                self.array_nature_definition()
                pass
            elif token in [vhdlParser.RECORD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 933
                self.record_nature_definition()
                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 Composite_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def array_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Array_type_definitionContext,0)


        def record_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Record_type_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_composite_type_definition

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

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

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




    def composite_type_definition(self):

        localctx = vhdlParser.Composite_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_composite_type_definition)
        try:
            self.state = 938
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ARRAY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 936
                self.array_type_definition()
                pass
            elif token in [vhdlParser.RECORD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 937
                self.record_type_definition()
                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 Concurrent_assertion_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assertion(self):
            return self.getTypedRuleContext(vhdlParser.AssertionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def POSTPONED(self):
            return self.getToken(vhdlParser.POSTPONED, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_assertion_statement

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

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

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




    def concurrent_assertion_statement(self):

        localctx = vhdlParser.Concurrent_assertion_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_concurrent_assertion_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 941
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 940
                self.label_colon()


            self.state = 944
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.POSTPONED:
                self.state = 943
                self.match(vhdlParser.POSTPONED)


            self.state = 946
            self.assertion()
            self.state = 947
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Concurrent_break_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BREAK(self):
            return self.getToken(vhdlParser.BREAK, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def break_list(self):
            return self.getTypedRuleContext(vhdlParser.Break_listContext,0)


        def sensitivity_clause(self):
            return self.getTypedRuleContext(vhdlParser.Sensitivity_clauseContext,0)


        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_break_statement

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

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

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




    def concurrent_break_statement(self):

        localctx = vhdlParser.Concurrent_break_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_concurrent_break_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 949
                self.label_colon()


            self.state = 952
            self.match(vhdlParser.BREAK)
            self.state = 954
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR or ((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 118)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 118)) | (1 << (vhdlParser.STRING_LITERAL - 118)))) != 0):
                self.state = 953
                self.break_list()


            self.state = 957
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ON:
                self.state = 956
                self.sensitivity_clause()


            self.state = 961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.WHEN:
                self.state = 959
                self.match(vhdlParser.WHEN)
                self.state = 960
                self.condition()


            self.state = 963
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Concurrent_procedure_call_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def procedure_call(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_callContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def POSTPONED(self):
            return self.getToken(vhdlParser.POSTPONED, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_procedure_call_statement

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

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

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




    def concurrent_procedure_call_statement(self):

        localctx = vhdlParser.Concurrent_procedure_call_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_concurrent_procedure_call_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 966
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 965
                self.label_colon()


            self.state = 969
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.POSTPONED:
                self.state = 968
                self.match(vhdlParser.POSTPONED)


            self.state = 971
            self.procedure_call()
            self.state = 972
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Concurrent_signal_assignment_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def conditional_signal_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_signal_assignmentContext,0)


        def selected_signal_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Selected_signal_assignmentContext,0)


        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def POSTPONED(self):
            return self.getToken(vhdlParser.POSTPONED, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_signal_assignment_statement

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

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

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




    def concurrent_signal_assignment_statement(self):

        localctx = vhdlParser.Concurrent_signal_assignment_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_concurrent_signal_assignment_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 974
                self.label_colon()


            self.state = 978
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.POSTPONED:
                self.state = 977
                self.match(vhdlParser.POSTPONED)


            self.state = 982
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN]:
                self.state = 980
                self.conditional_signal_assignment()
                pass
            elif token in [vhdlParser.WITH]:
                self.state = 981
                self.selected_signal_assignment()
                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 ConditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_condition

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

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

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




    def condition(self):

        localctx = vhdlParser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_condition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 984
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Condition_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNTIL(self):
            return self.getToken(vhdlParser.UNTIL, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_condition_clause

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

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

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




    def condition_clause(self):

        localctx = vhdlParser.Condition_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_condition_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 986
            self.match(vhdlParser.UNTIL)
            self.state = 987
            self.condition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Conditional_signal_assignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def LE(self):
            return self.getToken(vhdlParser.LE, 0)

        def opts(self):
            return self.getTypedRuleContext(vhdlParser.OptsContext,0)


        def conditional_waveforms(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_waveformsContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_signal_assignment

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

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

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




    def conditional_signal_assignment(self):

        localctx = vhdlParser.Conditional_signal_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_conditional_signal_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 989
            self.target()
            self.state = 990
            self.match(vhdlParser.LE)
            self.state = 991
            self.opts()
            self.state = 992
            self.conditional_waveforms()
            self.state = 993
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Conditional_waveformsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def waveform(self):
            return self.getTypedRuleContext(vhdlParser.WaveformContext,0)


        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def ELSE(self):
            return self.getToken(vhdlParser.ELSE, 0)

        def conditional_waveforms(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_waveformsContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_waveforms

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

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

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




    def conditional_waveforms(self):

        localctx = vhdlParser.Conditional_waveformsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_conditional_waveforms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 995
            self.waveform()
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.WHEN:
                self.state = 996
                self.match(vhdlParser.WHEN)
                self.state = 997
                self.condition()
                self.state = 1000
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.ELSE:
                    self.state = 998
                    self.match(vhdlParser.ELSE)
                    self.state = 999
                    self.conditional_waveforms()




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


    class Configuration_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

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


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def configuration_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Configuration_declarative_partContext,0)


        def block_configuration(self):
            return self.getTypedRuleContext(vhdlParser.Block_configurationContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_configuration_declaration

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

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

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




    def configuration_declaration(self):

        localctx = vhdlParser.Configuration_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_configuration_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1004
            self.match(vhdlParser.CONFIGURATION)
            self.state = 1005
            self.identifier()
            self.state = 1006
            self.match(vhdlParser.OF)
            self.state = 1007
            self.name()
            self.state = 1008
            self.match(vhdlParser.IS)
            self.state = 1009
            self.configuration_declarative_part()
            self.state = 1010
            self.block_configuration()
            self.state = 1011
            self.match(vhdlParser.END)
            self.state = 1013
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.CONFIGURATION:
                self.state = 1012
                self.match(vhdlParser.CONFIGURATION)


            self.state = 1016
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1015
                self.identifier()


            self.state = 1018
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Configuration_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_configuration_declarative_item

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

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

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




    def configuration_declarative_item(self):

        localctx = vhdlParser.Configuration_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_configuration_declarative_item)
        try:
            self.state = 1023
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.USE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1020
                self.use_clause()
                pass
            elif token in [vhdlParser.ATTRIBUTE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1021
                self.attribute_specification()
                pass
            elif token in [vhdlParser.GROUP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1022
                self.group_declaration()
                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 Configuration_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def configuration_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Configuration_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Configuration_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_configuration_declarative_part

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

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

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




    def configuration_declarative_part(self):

        localctx = vhdlParser.Configuration_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_configuration_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.ATTRIBUTE or _la==vhdlParser.GROUP or _la==vhdlParser.USE:
                self.state = 1025
                self.configuration_declarative_item()
                self.state = 1030
                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 Configuration_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block_configuration(self):
            return self.getTypedRuleContext(vhdlParser.Block_configurationContext,0)


        def component_configuration(self):
            return self.getTypedRuleContext(vhdlParser.Component_configurationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_configuration_item

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

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

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




    def configuration_item(self):

        localctx = vhdlParser.Configuration_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_configuration_item)
        try:
            self.state = 1033
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1031
                self.block_configuration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1032
                self.component_configuration()
                pass


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


    class Configuration_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(vhdlParser.FOR, 0)

        def component_specification(self):
            return self.getTypedRuleContext(vhdlParser.Component_specificationContext,0)


        def binding_indication(self):
            return self.getTypedRuleContext(vhdlParser.Binding_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_configuration_specification

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

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

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




    def configuration_specification(self):

        localctx = vhdlParser.Configuration_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_configuration_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1035
            self.match(vhdlParser.FOR)
            self.state = 1036
            self.component_specification()
            self.state = 1037
            self.binding_indication()
            self.state = 1038
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constant_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONSTANT(self):
            return self.getToken(vhdlParser.CONSTANT, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_constant_declaration

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

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

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




    def constant_declaration(self):

        localctx = vhdlParser.Constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_constant_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1040
            self.match(vhdlParser.CONSTANT)
            self.state = 1041
            self.identifier_list()
            self.state = 1042
            self.match(vhdlParser.COLON)
            self.state = 1043
            self.subtype_indication()
            self.state = 1046
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1044
                self.match(vhdlParser.VARASGN)
                self.state = 1045
                self.expression()


            self.state = 1048
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constrained_array_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ARRAY(self):
            return self.getToken(vhdlParser.ARRAY, 0)

        def index_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Index_constraintContext,0)


        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_constrained_array_definition

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

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

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




    def constrained_array_definition(self):

        localctx = vhdlParser.Constrained_array_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_constrained_array_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1050
            self.match(vhdlParser.ARRAY)
            self.state = 1051
            self.index_constraint()
            self.state = 1052
            self.match(vhdlParser.OF)
            self.state = 1053
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constrained_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ARRAY(self):
            return self.getToken(vhdlParser.ARRAY, 0)

        def index_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Index_constraintContext,0)


        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_constrained_nature_definition

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

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

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




    def constrained_nature_definition(self):

        localctx = vhdlParser.Constrained_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_constrained_nature_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1055
            self.match(vhdlParser.ARRAY)
            self.state = 1056
            self.index_constraint()
            self.state = 1057
            self.match(vhdlParser.OF)
            self.state = 1058
            self.subnature_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def range_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Range_constraintContext,0)


        def index_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Index_constraintContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_constraint

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

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

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




    def constraint(self):

        localctx = vhdlParser.ConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_constraint)
        try:
            self.state = 1062
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1060
                self.range_constraint()
                pass
            elif token in [vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1061
                self.index_constraint()
                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 Context_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def context_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Context_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Context_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_context_clause

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

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

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




    def context_clause(self):

        localctx = vhdlParser.Context_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_context_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1067
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.LIBRARY or _la==vhdlParser.USE:
                self.state = 1064
                self.context_item()
                self.state = 1069
                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 Context_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def library_clause(self):
            return self.getTypedRuleContext(vhdlParser.Library_clauseContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_context_item

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

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

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




    def context_item(self):

        localctx = vhdlParser.Context_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_context_item)
        try:
            self.state = 1072
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.LIBRARY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1070
                self.library_clause()
                pass
            elif token in [vhdlParser.USE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1071
                self.use_clause()
                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 Delay_mechanismContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TRANSPORT(self):
            return self.getToken(vhdlParser.TRANSPORT, 0)

        def INERTIAL(self):
            return self.getToken(vhdlParser.INERTIAL, 0)

        def REJECT(self):
            return self.getToken(vhdlParser.REJECT, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_delay_mechanism

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

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

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




    def delay_mechanism(self):

        localctx = vhdlParser.Delay_mechanismContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_delay_mechanism)
        self._la = 0 # Token type
        try:
            self.state = 1080
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.TRANSPORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1074
                self.match(vhdlParser.TRANSPORT)
                pass
            elif token in [vhdlParser.INERTIAL, vhdlParser.REJECT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1077
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.REJECT:
                    self.state = 1075
                    self.match(vhdlParser.REJECT)
                    self.state = 1076
                    self.expression()


                self.state = 1079
                self.match(vhdlParser.INERTIAL)
                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 Design_fileContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def design_unit(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Design_unitContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Design_unitContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_design_file

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

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

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




    def design_file(self):

        localctx = vhdlParser.Design_fileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_design_file)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1085
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ARCHITECTURE) | (1 << vhdlParser.CONFIGURATION) | (1 << vhdlParser.ENTITY) | (1 << vhdlParser.LIBRARY))) != 0) or _la==vhdlParser.PACKAGE or _la==vhdlParser.USE:
                self.state = 1082
                self.design_unit()
                self.state = 1087
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1088
            self.match(vhdlParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Design_unitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def context_clause(self):
            return self.getTypedRuleContext(vhdlParser.Context_clauseContext,0)


        def library_unit(self):
            return self.getTypedRuleContext(vhdlParser.Library_unitContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_design_unit

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

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

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




    def design_unit(self):

        localctx = vhdlParser.Design_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_design_unit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            self.context_clause()
            self.state = 1091
            self.library_unit()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DesignatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_designator

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

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

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




    def designator(self):

        localctx = vhdlParser.DesignatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_designator)
        try:
            self.state = 1095
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1093
                self.identifier()
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1094
                self.match(vhdlParser.STRING_LITERAL)
                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 DirectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TO(self):
            return self.getToken(vhdlParser.TO, 0)

        def DOWNTO(self):
            return self.getToken(vhdlParser.DOWNTO, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_direction

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

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

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




    def direction(self):

        localctx = vhdlParser.DirectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_direction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            _la = self._input.LA(1)
            if not(_la==vhdlParser.DOWNTO or _la==vhdlParser.TO):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Disconnection_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DISCONNECT(self):
            return self.getToken(vhdlParser.DISCONNECT, 0)

        def guarded_signal_specification(self):
            return self.getTypedRuleContext(vhdlParser.Guarded_signal_specificationContext,0)


        def AFTER(self):
            return self.getToken(vhdlParser.AFTER, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_disconnection_specification

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

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

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




    def disconnection_specification(self):

        localctx = vhdlParser.Disconnection_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_disconnection_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1099
            self.match(vhdlParser.DISCONNECT)
            self.state = 1100
            self.guarded_signal_specification()
            self.state = 1101
            self.match(vhdlParser.AFTER)
            self.state = 1102
            self.expression()
            self.state = 1103
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Discrete_rangeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def range_decl(self):
            return self.getTypedRuleContext(vhdlParser.Range_declContext,0)


        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_discrete_range

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

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

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




    def discrete_range(self):

        localctx = vhdlParser.Discrete_rangeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_discrete_range)
        try:
            self.state = 1107
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1105
                self.range_decl()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1106
                self.subtype_indication()
                pass


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


    class Element_associationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def choices(self):
            return self.getTypedRuleContext(vhdlParser.ChoicesContext,0)


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_element_association

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

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

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




    def element_association(self):

        localctx = vhdlParser.Element_associationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_element_association)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1112
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 1109
                self.choices()
                self.state = 1110
                self.match(vhdlParser.ARROW)


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


    class Element_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def element_subtype_definition(self):
            return self.getTypedRuleContext(vhdlParser.Element_subtype_definitionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_element_declaration

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

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

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




    def element_declaration(self):

        localctx = vhdlParser.Element_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_element_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1116
            self.identifier_list()
            self.state = 1117
            self.match(vhdlParser.COLON)
            self.state = 1118
            self.element_subtype_definition()
            self.state = 1119
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Element_subnature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_element_subnature_definition

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

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

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




    def element_subnature_definition(self):

        localctx = vhdlParser.Element_subnature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_element_subnature_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1121
            self.subnature_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Element_subtype_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_element_subtype_definition

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

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

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




    def element_subtype_definition(self):

        localctx = vhdlParser.Element_subtype_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_element_subtype_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1123
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Entity_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENTITY(self):
            return self.getToken(vhdlParser.ENTITY, 0)

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


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def CONFIGURATION(self):
            return self.getToken(vhdlParser.CONFIGURATION, 0)

        def OPEN(self):
            return self.getToken(vhdlParser.OPEN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_aspect

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

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

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




    def entity_aspect(self):

        localctx = vhdlParser.Entity_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_entity_aspect)
        self._la = 0 # Token type
        try:
            self.state = 1136
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ENTITY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1125
                self.match(vhdlParser.ENTITY)
                self.state = 1126
                self.name()
                self.state = 1131
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.LPAREN:
                    self.state = 1127
                    self.match(vhdlParser.LPAREN)
                    self.state = 1128
                    self.identifier()
                    self.state = 1129
                    self.match(vhdlParser.RPAREN)


                pass
            elif token in [vhdlParser.CONFIGURATION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1133
                self.match(vhdlParser.CONFIGURATION)
                self.state = 1134
                self.name()
                pass
            elif token in [vhdlParser.OPEN]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1135
                self.match(vhdlParser.OPEN)
                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 Entity_classContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENTITY(self):
            return self.getToken(vhdlParser.ENTITY, 0)

        def ARCHITECTURE(self):
            return self.getToken(vhdlParser.ARCHITECTURE, 0)

        def CONFIGURATION(self):
            return self.getToken(vhdlParser.CONFIGURATION, 0)

        def PROCEDURE(self):
            return self.getToken(vhdlParser.PROCEDURE, 0)

        def FUNCTION(self):
            return self.getToken(vhdlParser.FUNCTION, 0)

        def PACKAGE(self):
            return self.getToken(vhdlParser.PACKAGE, 0)

        def TYPE(self):
            return self.getToken(vhdlParser.TYPE, 0)

        def SUBTYPE(self):
            return self.getToken(vhdlParser.SUBTYPE, 0)

        def CONSTANT(self):
            return self.getToken(vhdlParser.CONSTANT, 0)

        def SIGNAL(self):
            return self.getToken(vhdlParser.SIGNAL, 0)

        def VARIABLE(self):
            return self.getToken(vhdlParser.VARIABLE, 0)

        def COMPONENT(self):
            return self.getToken(vhdlParser.COMPONENT, 0)

        def LABEL(self):
            return self.getToken(vhdlParser.LABEL, 0)

        def LITERAL(self):
            return self.getToken(vhdlParser.LITERAL, 0)

        def UNITS(self):
            return self.getToken(vhdlParser.UNITS, 0)

        def GROUP(self):
            return self.getToken(vhdlParser.GROUP, 0)

        def FILE(self):
            return self.getToken(vhdlParser.FILE, 0)

        def NATURE(self):
            return self.getToken(vhdlParser.NATURE, 0)

        def SUBNATURE(self):
            return self.getToken(vhdlParser.SUBNATURE, 0)

        def QUANTITY(self):
            return self.getToken(vhdlParser.QUANTITY, 0)

        def TERMINAL(self):
            return self.getToken(vhdlParser.TERMINAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_class

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

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

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




    def entity_class(self):

        localctx = vhdlParser.Entity_classContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_entity_class)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1138
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ARCHITECTURE) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONFIGURATION) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.ENTITY) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.LABEL) | (1 << vhdlParser.LITERAL) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vhdlParser.PACKAGE - 64)) | (1 << (vhdlParser.PROCEDURE - 64)) | (1 << (vhdlParser.QUANTITY - 64)) | (1 << (vhdlParser.SIGNAL - 64)) | (1 << (vhdlParser.SUBNATURE - 64)) | (1 << (vhdlParser.SUBTYPE - 64)) | (1 << (vhdlParser.TERMINAL - 64)) | (1 << (vhdlParser.TYPE - 64)) | (1 << (vhdlParser.UNITS - 64)) | (1 << (vhdlParser.VARIABLE - 64)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Entity_class_entryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_class(self):
            return self.getTypedRuleContext(vhdlParser.Entity_classContext,0)


        def BOX(self):
            return self.getToken(vhdlParser.BOX, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_class_entry

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

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

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




    def entity_class_entry(self):

        localctx = vhdlParser.Entity_class_entryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_entity_class_entry)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1140
            self.entity_class()
            self.state = 1142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BOX:
                self.state = 1141
                self.match(vhdlParser.BOX)


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


    class Entity_class_entry_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_class_entry(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Entity_class_entryContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Entity_class_entryContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_class_entry_list

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

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

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




    def entity_class_entry_list(self):

        localctx = vhdlParser.Entity_class_entry_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_entity_class_entry_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1144
            self.entity_class_entry()
            self.state = 1149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1145
                self.match(vhdlParser.COMMA)
                self.state = 1146
                self.entity_class_entry()
                self.state = 1151
                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 Entity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def entity_header(self):
            return self.getTypedRuleContext(vhdlParser.Entity_headerContext,0)


        def entity_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Entity_declarative_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def entity_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Entity_statement_partContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_declaration

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

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

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




    def entity_declaration(self):

        localctx = vhdlParser.Entity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_entity_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1152
            self.match(vhdlParser.ENTITY)
            self.state = 1153
            self.identifier()
            self.state = 1154
            self.match(vhdlParser.IS)
            self.state = 1155
            self.entity_header()
            self.state = 1156
            self.entity_declarative_part()
            self.state = 1159
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BEGIN:
                self.state = 1157
                self.match(vhdlParser.BEGIN)
                self.state = 1158
                self.entity_statement_part()


            self.state = 1161
            self.match(vhdlParser.END)
            self.state = 1163
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ENTITY:
                self.state = 1162
                self.match(vhdlParser.ENTITY)


            self.state = 1166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1165
                self.identifier()


            self.state = 1168
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Entity_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def signal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Signal_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def disconnection_specification(self):
            return self.getTypedRuleContext(vhdlParser.Disconnection_specificationContext,0)


        def step_limit_specification(self):
            return self.getTypedRuleContext(vhdlParser.Step_limit_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def nature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Nature_declarationContext,0)


        def subnature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_declarationContext,0)


        def quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Quantity_declarationContext,0)


        def terminal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Terminal_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_declarative_item

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

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

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




    def entity_declarative_item(self):

        localctx = vhdlParser.Entity_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_entity_declarative_item)
        try:
            self.state = 1190
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1170
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1171
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1172
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1173
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1174
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1175
                self.signal_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1176
                self.variable_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1177
                self.file_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1178
                self.alias_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1179
                self.attribute_declaration()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1180
                self.attribute_specification()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1181
                self.disconnection_specification()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1182
                self.step_limit_specification()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1183
                self.use_clause()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1184
                self.group_template_declaration()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1185
                self.group_declaration()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1186
                self.nature_declaration()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1187
                self.subnature_declaration()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1188
                self.quantity_declaration()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1189
                self.terminal_declaration()
                pass


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


    class Entity_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Entity_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Entity_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_declarative_part

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

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

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




    def entity_declarative_part(self):

        localctx = vhdlParser.Entity_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_entity_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.LIMIT) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.QUANTITY - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1192
                self.entity_declarative_item()
                self.state = 1197
                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 Entity_designatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_tag(self):
            return self.getTypedRuleContext(vhdlParser.Entity_tagContext,0)


        def signature(self):
            return self.getTypedRuleContext(vhdlParser.SignatureContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_designator

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

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

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




    def entity_designator(self):

        localctx = vhdlParser.Entity_designatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_entity_designator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1198
            self.entity_tag()
            self.state = 1200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LBRACKET:
                self.state = 1199
                self.signature()


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


    class Entity_headerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def generic_clause(self):
            return self.getTypedRuleContext(vhdlParser.Generic_clauseContext,0)


        def port_clause(self):
            return self.getTypedRuleContext(vhdlParser.Port_clauseContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_header

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

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

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




    def entity_header(self):

        localctx = vhdlParser.Entity_headerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_entity_header)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GENERIC:
                self.state = 1202
                self.generic_clause()


            self.state = 1206
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PORT:
                self.state = 1205
                self.port_clause()


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


    class Entity_name_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_designator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Entity_designatorContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Entity_designatorContext,i)


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

        def OTHERS(self):
            return self.getToken(vhdlParser.OTHERS, 0)

        def ALL(self):
            return self.getToken(vhdlParser.ALL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_name_list

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

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

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




    def entity_name_list(self):

        localctx = vhdlParser.Entity_name_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_entity_name_list)
        self._la = 0 # Token type
        try:
            self.state = 1218
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1208
                self.entity_designator()
                self.state = 1213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1209
                    self.match(vhdlParser.COMMA)
                    self.state = 1210
                    self.entity_designator()
                    self.state = 1215
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1216
                self.match(vhdlParser.OTHERS)
                pass
            elif token in [vhdlParser.ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1217
                self.match(vhdlParser.ALL)
                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 Entity_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_name_list(self):
            return self.getTypedRuleContext(vhdlParser.Entity_name_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def entity_class(self):
            return self.getTypedRuleContext(vhdlParser.Entity_classContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_specification

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

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

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




    def entity_specification(self):

        localctx = vhdlParser.Entity_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_entity_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1220
            self.entity_name_list()
            self.state = 1221
            self.match(vhdlParser.COLON)
            self.state = 1222
            self.entity_class()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Entity_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def concurrent_assertion_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_assertion_statementContext,0)


        def process_statement(self):
            return self.getTypedRuleContext(vhdlParser.Process_statementContext,0)


        def concurrent_procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_procedure_call_statementContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_statement

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

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

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




    def entity_statement(self):

        localctx = vhdlParser.Entity_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_entity_statement)
        try:
            self.state = 1227
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1224
                self.concurrent_assertion_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1225
                self.process_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1226
                self.concurrent_procedure_call_statement()
                pass


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


    class Entity_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Entity_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Entity_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_entity_statement_part

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

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

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




    def entity_statement_part(self):

        localctx = vhdlParser.Entity_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_entity_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.ASSERT or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (vhdlParser.POSTPONED - 66)) | (1 << (vhdlParser.PROCESS - 66)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 66)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 66)))) != 0):
                self.state = 1229
                self.entity_statement()
                self.state = 1234
                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 Entity_tagContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def CHARACTER_LITERAL(self):
            return self.getToken(vhdlParser.CHARACTER_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_entity_tag

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

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

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




    def entity_tag(self):

        localctx = vhdlParser.Entity_tagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_entity_tag)
        try:
            self.state = 1238
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1235
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1236
                self.match(vhdlParser.CHARACTER_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1237
                self.match(vhdlParser.STRING_LITERAL)
                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 Enumeration_literalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def CHARACTER_LITERAL(self):
            return self.getToken(vhdlParser.CHARACTER_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_enumeration_literal

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

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

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




    def enumeration_literal(self):

        localctx = vhdlParser.Enumeration_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_enumeration_literal)
        try:
            self.state = 1242
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1240
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1241
                self.match(vhdlParser.CHARACTER_LITERAL)
                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 Enumeration_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def enumeration_literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Enumeration_literalContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Enumeration_literalContext,i)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

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

        def getRuleIndex(self):
            return vhdlParser.RULE_enumeration_type_definition

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

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

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




    def enumeration_type_definition(self):

        localctx = vhdlParser.Enumeration_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_enumeration_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1244
            self.match(vhdlParser.LPAREN)
            self.state = 1245
            self.enumeration_literal()
            self.state = 1250
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1246
                self.match(vhdlParser.COMMA)
                self.state = 1247
                self.enumeration_literal()
                self.state = 1252
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1253
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Exit_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EXIT(self):
            return self.getToken(vhdlParser.EXIT, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_exit_statement

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

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

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




    def exit_statement(self):

        localctx = vhdlParser.Exit_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_exit_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1256
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1255
                self.label_colon()


            self.state = 1258
            self.match(vhdlParser.EXIT)
            self.state = 1260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1259
                self.identifier()


            self.state = 1264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.WHEN:
                self.state = 1262
                self.match(vhdlParser.WHEN)
                self.state = 1263
                self.condition()


            self.state = 1266
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.RelationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.RelationContext,i)


        def logical_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Logical_operatorContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Logical_operatorContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_expression

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

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

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




    def expression(self):

        localctx = vhdlParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1268
            self.relation()
            self.state = 1274
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,116,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1269
                    self.logical_operator()
                    self.state = 1270
                    self.relation() 
                self.state = 1276
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,116,self._ctx)

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


    class FactorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def primary(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.PrimaryContext)
            else:
                return self.getTypedRuleContext(vhdlParser.PrimaryContext,i)


        def DOUBLESTAR(self):
            return self.getToken(vhdlParser.DOUBLESTAR, 0)

        def ABS(self):
            return self.getToken(vhdlParser.ABS, 0)

        def NOT(self):
            return self.getToken(vhdlParser.NOT, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_factor

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

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

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




    def factor(self):

        localctx = vhdlParser.FactorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_factor)
        try:
            self.state = 1286
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.NEW, vhdlParser.NULL_, vhdlParser.BASE_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.REAL_LITERAL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.INTEGER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1277
                self.primary()
                self.state = 1280
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 1278
                    self.match(vhdlParser.DOUBLESTAR)
                    self.state = 1279
                    self.primary()


                pass
            elif token in [vhdlParser.ABS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1282
                self.match(vhdlParser.ABS)
                self.state = 1283
                self.primary()
                pass
            elif token in [vhdlParser.NOT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1284
                self.match(vhdlParser.NOT)
                self.state = 1285
                self.primary()
                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 File_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILE(self):
            return self.getToken(vhdlParser.FILE, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def file_open_information(self):
            return self.getTypedRuleContext(vhdlParser.File_open_informationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_file_declaration

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

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

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




    def file_declaration(self):

        localctx = vhdlParser.File_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_file_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1288
            self.match(vhdlParser.FILE)
            self.state = 1289
            self.identifier_list()
            self.state = 1290
            self.match(vhdlParser.COLON)
            self.state = 1291
            self.subtype_indication()
            self.state = 1293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS or _la==vhdlParser.OPEN:
                self.state = 1292
                self.file_open_information()


            self.state = 1295
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class File_logical_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_file_logical_name

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

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

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




    def file_logical_name(self):

        localctx = vhdlParser.File_logical_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_file_logical_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1297
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class File_open_informationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def file_logical_name(self):
            return self.getTypedRuleContext(vhdlParser.File_logical_nameContext,0)


        def OPEN(self):
            return self.getToken(vhdlParser.OPEN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_file_open_information

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

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

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




    def file_open_information(self):

        localctx = vhdlParser.File_open_informationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_file_open_information)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1301
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.OPEN:
                self.state = 1299
                self.match(vhdlParser.OPEN)
                self.state = 1300
                self.expression()


            self.state = 1303
            self.match(vhdlParser.IS)
            self.state = 1304
            self.file_logical_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class File_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILE(self):
            return self.getToken(vhdlParser.FILE, 0)

        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_file_type_definition

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

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

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




    def file_type_definition(self):

        localctx = vhdlParser.File_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_file_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1306
            self.match(vhdlParser.FILE)
            self.state = 1307
            self.match(vhdlParser.OF)
            self.state = 1308
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Formal_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_list(self):
            return self.getTypedRuleContext(vhdlParser.Interface_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_formal_parameter_list

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

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

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




    def formal_parameter_list(self):

        localctx = vhdlParser.Formal_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_formal_parameter_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1310
            self.interface_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Formal_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def explicit_range(self):
            return self.getTypedRuleContext(vhdlParser.Explicit_rangeContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_formal_part

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

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

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




    def formal_part(self):

        localctx = vhdlParser.Formal_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_formal_part)
        try:
            self.state = 1318
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1312
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1313
                self.identifier()
                self.state = 1314
                self.match(vhdlParser.LPAREN)
                self.state = 1315
                self.explicit_range()
                self.state = 1316
                self.match(vhdlParser.RPAREN)
                pass


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


    class Free_quantity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QUANTITY(self):
            return self.getToken(vhdlParser.QUANTITY, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_free_quantity_declaration

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

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

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




    def free_quantity_declaration(self):

        localctx = vhdlParser.Free_quantity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_free_quantity_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1320
            self.match(vhdlParser.QUANTITY)
            self.state = 1321
            self.identifier_list()
            self.state = 1322
            self.match(vhdlParser.COLON)
            self.state = 1323
            self.subtype_indication()
            self.state = 1326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1324
                self.match(vhdlParser.VARASGN)
                self.state = 1325
                self.expression()


            self.state = 1328
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Generate_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def generation_scheme(self):
            return self.getTypedRuleContext(vhdlParser.Generation_schemeContext,0)


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

        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def architecture_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Architecture_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Architecture_statementContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def block_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Block_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Block_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_generate_statement

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

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

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




    def generate_statement(self):

        localctx = vhdlParser.Generate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_generate_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1330
            self.label_colon()
            self.state = 1331
            self.generation_scheme()
            self.state = 1332
            self.match(vhdlParser.GENERATE)
            self.state = 1340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.BEGIN) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FOR) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.LIMIT) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.QUANTITY - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FOR) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.LIMIT) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.QUANTITY - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                    self.state = 1333
                    self.block_declarative_item()
                    self.state = 1338
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1339
                self.match(vhdlParser.BEGIN)


            self.state = 1345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ABS) | (1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.IF) | (1 << vhdlParser.NEW) | (1 << vhdlParser.NOT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (vhdlParser.POSTPONED - 66)) | (1 << (vhdlParser.PROCESS - 66)) | (1 << (vhdlParser.PROCEDURAL - 66)) | (1 << (vhdlParser.WITH - 66)) | (1 << (vhdlParser.BASE_LITERAL - 66)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 66)) | (1 << (vhdlParser.REAL_LITERAL - 66)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 66)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 66)) | (1 << (vhdlParser.CHARACTER_LITERAL - 66)) | (1 << (vhdlParser.STRING_LITERAL - 66)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (vhdlParser.LPAREN - 141)) | (1 << (vhdlParser.PLUS - 141)) | (1 << (vhdlParser.MINUS - 141)) | (1 << (vhdlParser.INTEGER - 141)))) != 0):
                self.state = 1342
                self.architecture_statement()
                self.state = 1347
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1348
            self.match(vhdlParser.END)
            self.state = 1349
            self.match(vhdlParser.GENERATE)
            self.state = 1351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1350
                self.identifier()


            self.state = 1353
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Generation_schemeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(vhdlParser.FOR, 0)

        def parameter_specification(self):
            return self.getTypedRuleContext(vhdlParser.Parameter_specificationContext,0)


        def IF(self):
            return self.getToken(vhdlParser.IF, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_generation_scheme

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

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

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




    def generation_scheme(self):

        localctx = vhdlParser.Generation_schemeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_generation_scheme)
        try:
            self.state = 1359
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.FOR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1355
                self.match(vhdlParser.FOR)
                self.state = 1356
                self.parameter_specification()
                pass
            elif token in [vhdlParser.IF]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1357
                self.match(vhdlParser.IF)
                self.state = 1358
                self.condition()
                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 Generic_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GENERIC(self):
            return self.getToken(vhdlParser.GENERIC, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def generic_list(self):
            return self.getTypedRuleContext(vhdlParser.Generic_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_generic_clause

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

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

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




    def generic_clause(self):

        localctx = vhdlParser.Generic_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_generic_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1361
            self.match(vhdlParser.GENERIC)
            self.state = 1362
            self.match(vhdlParser.LPAREN)
            self.state = 1363
            self.generic_list()
            self.state = 1364
            self.match(vhdlParser.RPAREN)
            self.state = 1365
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Generic_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_constant_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Interface_constant_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Interface_constant_declarationContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_generic_list

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

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

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




    def generic_list(self):

        localctx = vhdlParser.Generic_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_generic_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1367
            self.interface_constant_declaration()
            self.state = 1372
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.SEMI:
                self.state = 1368
                self.match(vhdlParser.SEMI)
                self.state = 1369
                self.interface_constant_declaration()
                self.state = 1374
                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 Generic_map_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GENERIC(self):
            return self.getToken(vhdlParser.GENERIC, 0)

        def MAP(self):
            return self.getToken(vhdlParser.MAP, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def association_list(self):
            return self.getTypedRuleContext(vhdlParser.Association_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_generic_map_aspect

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

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

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




    def generic_map_aspect(self):

        localctx = vhdlParser.Generic_map_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_generic_map_aspect)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1375
            self.match(vhdlParser.GENERIC)
            self.state = 1376
            self.match(vhdlParser.MAP)
            self.state = 1377
            self.match(vhdlParser.LPAREN)
            self.state = 1378
            self.association_list()
            self.state = 1379
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Group_constituentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def CHARACTER_LITERAL(self):
            return self.getToken(vhdlParser.CHARACTER_LITERAL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_group_constituent

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

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

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




    def group_constituent(self):

        localctx = vhdlParser.Group_constituentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_group_constituent)
        try:
            self.state = 1383
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1381
                self.name()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1382
                self.match(vhdlParser.CHARACTER_LITERAL)
                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 Group_constituent_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def group_constituent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Group_constituentContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Group_constituentContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_group_constituent_list

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

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

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




    def group_constituent_list(self):

        localctx = vhdlParser.Group_constituent_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_group_constituent_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385
            self.group_constituent()
            self.state = 1390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1386
                self.match(vhdlParser.COMMA)
                self.state = 1387
                self.group_constituent()
                self.state = 1392
                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 Group_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GROUP(self):
            return self.getToken(vhdlParser.GROUP, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


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


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def group_constituent_list(self):
            return self.getTypedRuleContext(vhdlParser.Group_constituent_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_group_declaration

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

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

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




    def group_declaration(self):

        localctx = vhdlParser.Group_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_group_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1393
            self.match(vhdlParser.GROUP)
            self.state = 1394
            self.label_colon()
            self.state = 1395
            self.name()
            self.state = 1396
            self.match(vhdlParser.LPAREN)
            self.state = 1397
            self.group_constituent_list()
            self.state = 1398
            self.match(vhdlParser.RPAREN)
            self.state = 1399
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Group_template_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GROUP(self):
            return self.getToken(vhdlParser.GROUP, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def entity_class_entry_list(self):
            return self.getTypedRuleContext(vhdlParser.Entity_class_entry_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_group_template_declaration

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

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

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




    def group_template_declaration(self):

        localctx = vhdlParser.Group_template_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_group_template_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1401
            self.match(vhdlParser.GROUP)
            self.state = 1402
            self.identifier()
            self.state = 1403
            self.match(vhdlParser.IS)
            self.state = 1404
            self.match(vhdlParser.LPAREN)
            self.state = 1405
            self.entity_class_entry_list()
            self.state = 1406
            self.match(vhdlParser.RPAREN)
            self.state = 1407
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Guarded_signal_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def signal_list(self):
            return self.getTypedRuleContext(vhdlParser.Signal_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

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


        def getRuleIndex(self):
            return vhdlParser.RULE_guarded_signal_specification

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

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

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




    def guarded_signal_specification(self):

        localctx = vhdlParser.Guarded_signal_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_guarded_signal_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1409
            self.signal_list()
            self.state = 1410
            self.match(vhdlParser.COLON)
            self.state = 1411
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BASIC_IDENTIFIER(self):
            return self.getToken(vhdlParser.BASIC_IDENTIFIER, 0)

        def EXTENDED_IDENTIFIER(self):
            return self.getToken(vhdlParser.EXTENDED_IDENTIFIER, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_identifier

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

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

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




    def identifier(self):

        localctx = vhdlParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1413
            _la = self._input.LA(1)
            if not(_la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Identifier_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_identifier_list

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

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

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




    def identifier_list(self):

        localctx = vhdlParser.Identifier_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_identifier_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1415
            self.identifier()
            self.state = 1420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1416
                self.match(vhdlParser.COMMA)
                self.state = 1417
                self.identifier()
                self.state = 1422
                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 If_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ConditionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ConditionContext,i)


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

        def sequence_of_statements(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Sequence_of_statementsContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Sequence_of_statementsContext,i)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


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

        def ELSE(self):
            return self.getToken(vhdlParser.ELSE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_if_statement

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

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

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




    def if_statement(self):

        localctx = vhdlParser.If_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_if_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1424
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1423
                self.label_colon()


            self.state = 1426
            self.match(vhdlParser.IF)
            self.state = 1427
            self.condition()
            self.state = 1428
            self.match(vhdlParser.THEN)
            self.state = 1429
            self.sequence_of_statements()
            self.state = 1437
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.ELSIF:
                self.state = 1430
                self.match(vhdlParser.ELSIF)
                self.state = 1431
                self.condition()
                self.state = 1432
                self.match(vhdlParser.THEN)
                self.state = 1433
                self.sequence_of_statements()
                self.state = 1439
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ELSE:
                self.state = 1440
                self.match(vhdlParser.ELSE)
                self.state = 1441
                self.sequence_of_statements()


            self.state = 1444
            self.match(vhdlParser.END)
            self.state = 1445
            self.match(vhdlParser.IF)
            self.state = 1447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1446
                self.identifier()


            self.state = 1449
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Index_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def discrete_range(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Discrete_rangeContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Discrete_rangeContext,i)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

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

        def getRuleIndex(self):
            return vhdlParser.RULE_index_constraint

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

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

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




    def index_constraint(self):

        localctx = vhdlParser.Index_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_index_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1451
            self.match(vhdlParser.LPAREN)
            self.state = 1452
            self.discrete_range()
            self.state = 1457
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1453
                self.match(vhdlParser.COMMA)
                self.state = 1454
                self.discrete_range()
                self.state = 1459
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1460
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Index_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def discrete_range(self):
            return self.getTypedRuleContext(vhdlParser.Discrete_rangeContext,0)


        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_index_specification

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

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

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




    def index_specification(self):

        localctx = vhdlParser.Index_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_index_specification)
        try:
            self.state = 1464
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1462
                self.discrete_range()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1463
                self.expression()
                pass


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


    class Index_subtype_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def RANGE(self):
            return self.getToken(vhdlParser.RANGE, 0)

        def BOX(self):
            return self.getToken(vhdlParser.BOX, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_index_subtype_definition

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

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

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




    def index_subtype_definition(self):

        localctx = vhdlParser.Index_subtype_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_index_subtype_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1466
            self.name()
            self.state = 1467
            self.match(vhdlParser.RANGE)
            self.state = 1468
            self.match(vhdlParser.BOX)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Instantiated_unitContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def COMPONENT(self):
            return self.getToken(vhdlParser.COMPONENT, 0)

        def ENTITY(self):
            return self.getToken(vhdlParser.ENTITY, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def CONFIGURATION(self):
            return self.getToken(vhdlParser.CONFIGURATION, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_instantiated_unit

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

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

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




    def instantiated_unit(self):

        localctx = vhdlParser.Instantiated_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_instantiated_unit)
        self._la = 0 # Token type
        try:
            self.state = 1484
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.COMPONENT, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1471
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.COMPONENT:
                    self.state = 1470
                    self.match(vhdlParser.COMPONENT)


                self.state = 1473
                self.name()
                pass
            elif token in [vhdlParser.ENTITY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1474
                self.match(vhdlParser.ENTITY)
                self.state = 1475
                self.name()
                self.state = 1480
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.LPAREN:
                    self.state = 1476
                    self.match(vhdlParser.LPAREN)
                    self.state = 1477
                    self.identifier()
                    self.state = 1478
                    self.match(vhdlParser.RPAREN)


                pass
            elif token in [vhdlParser.CONFIGURATION]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1482
                self.match(vhdlParser.CONFIGURATION)
                self.state = 1483
                self.name()
                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 Instantiation_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


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

        def OTHERS(self):
            return self.getToken(vhdlParser.OTHERS, 0)

        def ALL(self):
            return self.getToken(vhdlParser.ALL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_instantiation_list

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

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

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




    def instantiation_list(self):

        localctx = vhdlParser.Instantiation_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_instantiation_list)
        self._la = 0 # Token type
        try:
            self.state = 1496
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1486
                self.identifier()
                self.state = 1491
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1487
                    self.match(vhdlParser.COMMA)
                    self.state = 1488
                    self.identifier()
                    self.state = 1493
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1494
                self.match(vhdlParser.OTHERS)
                pass
            elif token in [vhdlParser.ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1495
                self.match(vhdlParser.ALL)
                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 Interface_constant_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def CONSTANT(self):
            return self.getToken(vhdlParser.CONSTANT, 0)

        def IN(self):
            return self.getToken(vhdlParser.IN, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_constant_declaration

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

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

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




    def interface_constant_declaration(self):

        localctx = vhdlParser.Interface_constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_interface_constant_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1499
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.CONSTANT:
                self.state = 1498
                self.match(vhdlParser.CONSTANT)


            self.state = 1501
            self.identifier_list()
            self.state = 1502
            self.match(vhdlParser.COLON)
            self.state = 1504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IN:
                self.state = 1503
                self.match(vhdlParser.IN)


            self.state = 1506
            self.subtype_indication()
            self.state = 1509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1507
                self.match(vhdlParser.VARASGN)
                self.state = 1508
                self.expression()


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


    class Interface_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_constant_declarationContext,0)


        def interface_signal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_signal_declarationContext,0)


        def interface_variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_variable_declarationContext,0)


        def interface_file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_file_declarationContext,0)


        def interface_terminal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_terminal_declarationContext,0)


        def interface_quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_quantity_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_declaration

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

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

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




    def interface_declaration(self):

        localctx = vhdlParser.Interface_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_interface_declaration)
        try:
            self.state = 1517
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1511
                self.interface_constant_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1512
                self.interface_signal_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1513
                self.interface_variable_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1514
                self.interface_file_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1515
                self.interface_terminal_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1516
                self.interface_quantity_declaration()
                pass


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


    class Interface_elementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_element

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

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

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




    def interface_element(self):

        localctx = vhdlParser.Interface_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_interface_element)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1519
            self.interface_declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_file_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILE(self):
            return self.getToken(vhdlParser.FILE, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_file_declaration

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

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

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




    def interface_file_declaration(self):

        localctx = vhdlParser.Interface_file_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_interface_file_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1521
            self.match(vhdlParser.FILE)
            self.state = 1522
            self.identifier_list()
            self.state = 1523
            self.match(vhdlParser.COLON)
            self.state = 1524
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_signal_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_signal_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Interface_signal_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Interface_signal_declarationContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_signal_list

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

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

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




    def interface_signal_list(self):

        localctx = vhdlParser.Interface_signal_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_interface_signal_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1526
            self.interface_signal_declaration()
            self.state = 1531
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.SEMI:
                self.state = 1527
                self.match(vhdlParser.SEMI)
                self.state = 1528
                self.interface_signal_declaration()
                self.state = 1533
                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 Interface_port_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_port_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Interface_port_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Interface_port_declarationContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_port_list

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

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

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




    def interface_port_list(self):

        localctx = vhdlParser.Interface_port_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_interface_port_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1534
            self.interface_port_declaration()
            self.state = 1539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.SEMI:
                self.state = 1535
                self.match(vhdlParser.SEMI)
                self.state = 1536
                self.interface_port_declaration()
                self.state = 1541
                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 Interface_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Interface_elementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Interface_elementContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_list

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

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

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




    def interface_list(self):

        localctx = vhdlParser.Interface_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_interface_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1542
            self.interface_element()
            self.state = 1547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.SEMI:
                self.state = 1543
                self.match(vhdlParser.SEMI)
                self.state = 1544
                self.interface_element()
                self.state = 1549
                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 Interface_quantity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def QUANTITY(self):
            return self.getToken(vhdlParser.QUANTITY, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def IN(self):
            return self.getToken(vhdlParser.IN, 0)

        def OUT(self):
            return self.getToken(vhdlParser.OUT, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_quantity_declaration

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

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

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




    def interface_quantity_declaration(self):

        localctx = vhdlParser.Interface_quantity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_interface_quantity_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1550
            self.match(vhdlParser.QUANTITY)
            self.state = 1551
            self.identifier_list()
            self.state = 1552
            self.match(vhdlParser.COLON)
            self.state = 1554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IN or _la==vhdlParser.OUT:
                self.state = 1553
                _la = self._input.LA(1)
                if not(_la==vhdlParser.IN or _la==vhdlParser.OUT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1556
            self.subtype_indication()
            self.state = 1559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1557
                self.match(vhdlParser.VARASGN)
                self.state = 1558
                self.expression()


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


    class Interface_port_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def signal_mode(self):
            return self.getTypedRuleContext(vhdlParser.Signal_modeContext,0)


        def BUS(self):
            return self.getToken(vhdlParser.BUS, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_port_declaration

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

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

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




    def interface_port_declaration(self):

        localctx = vhdlParser.Interface_port_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_interface_port_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1561
            self.identifier_list()
            self.state = 1562
            self.match(vhdlParser.COLON)
            self.state = 1564
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.BUFFER) | (1 << vhdlParser.IN) | (1 << vhdlParser.INOUT) | (1 << vhdlParser.LINKAGE) | (1 << vhdlParser.OUT))) != 0):
                self.state = 1563
                self.signal_mode()


            self.state = 1566
            self.subtype_indication()
            self.state = 1568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BUS:
                self.state = 1567
                self.match(vhdlParser.BUS)


            self.state = 1572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1570
                self.match(vhdlParser.VARASGN)
                self.state = 1571
                self.expression()


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


    class Interface_signal_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SIGNAL(self):
            return self.getToken(vhdlParser.SIGNAL, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def signal_mode(self):
            return self.getTypedRuleContext(vhdlParser.Signal_modeContext,0)


        def BUS(self):
            return self.getToken(vhdlParser.BUS, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_signal_declaration

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

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

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




    def interface_signal_declaration(self):

        localctx = vhdlParser.Interface_signal_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_interface_signal_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1574
            self.match(vhdlParser.SIGNAL)
            self.state = 1575
            self.identifier_list()
            self.state = 1576
            self.match(vhdlParser.COLON)
            self.state = 1578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.BUFFER) | (1 << vhdlParser.IN) | (1 << vhdlParser.INOUT) | (1 << vhdlParser.LINKAGE) | (1 << vhdlParser.OUT))) != 0):
                self.state = 1577
                self.signal_mode()


            self.state = 1580
            self.subtype_indication()
            self.state = 1582
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BUS:
                self.state = 1581
                self.match(vhdlParser.BUS)


            self.state = 1586
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1584
                self.match(vhdlParser.VARASGN)
                self.state = 1585
                self.expression()


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


    class Interface_terminal_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TERMINAL(self):
            return self.getToken(vhdlParser.TERMINAL, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_terminal_declaration

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

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

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




    def interface_terminal_declaration(self):

        localctx = vhdlParser.Interface_terminal_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_interface_terminal_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1588
            self.match(vhdlParser.TERMINAL)
            self.state = 1589
            self.identifier_list()
            self.state = 1590
            self.match(vhdlParser.COLON)
            self.state = 1591
            self.subnature_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_variable_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def VARIABLE(self):
            return self.getToken(vhdlParser.VARIABLE, 0)

        def signal_mode(self):
            return self.getTypedRuleContext(vhdlParser.Signal_modeContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_variable_declaration

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

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

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




    def interface_variable_declaration(self):

        localctx = vhdlParser.Interface_variable_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_interface_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1594
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARIABLE:
                self.state = 1593
                self.match(vhdlParser.VARIABLE)


            self.state = 1596
            self.identifier_list()
            self.state = 1597
            self.match(vhdlParser.COLON)
            self.state = 1599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.BUFFER) | (1 << vhdlParser.IN) | (1 << vhdlParser.INOUT) | (1 << vhdlParser.LINKAGE) | (1 << vhdlParser.OUT))) != 0):
                self.state = 1598
                self.signal_mode()


            self.state = 1601
            self.subtype_indication()
            self.state = 1604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1602
                self.match(vhdlParser.VARASGN)
                self.state = 1603
                self.expression()


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


    class Iteration_schemeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHILE(self):
            return self.getToken(vhdlParser.WHILE, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def FOR(self):
            return self.getToken(vhdlParser.FOR, 0)

        def parameter_specification(self):
            return self.getTypedRuleContext(vhdlParser.Parameter_specificationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_iteration_scheme

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

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

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




    def iteration_scheme(self):

        localctx = vhdlParser.Iteration_schemeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_iteration_scheme)
        try:
            self.state = 1610
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.WHILE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1606
                self.match(vhdlParser.WHILE)
                self.state = 1607
                self.condition()
                pass
            elif token in [vhdlParser.FOR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1608
                self.match(vhdlParser.FOR)
                self.state = 1609
                self.parameter_specification()
                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 Label_colonContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_label_colon

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

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

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




    def label_colon(self):

        localctx = vhdlParser.Label_colonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_label_colon)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1612
            self.identifier()
            self.state = 1613
            self.match(vhdlParser.COLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Library_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LIBRARY(self):
            return self.getToken(vhdlParser.LIBRARY, 0)

        def logical_name_list(self):
            return self.getTypedRuleContext(vhdlParser.Logical_name_listContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_library_clause

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

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

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




    def library_clause(self):

        localctx = vhdlParser.Library_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_library_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1615
            self.match(vhdlParser.LIBRARY)
            self.state = 1616
            self.logical_name_list()
            self.state = 1617
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Library_unitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def secondary_unit(self):
            return self.getTypedRuleContext(vhdlParser.Secondary_unitContext,0)


        def primary_unit(self):
            return self.getTypedRuleContext(vhdlParser.Primary_unitContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_library_unit

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

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

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




    def library_unit(self):

        localctx = vhdlParser.Library_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_library_unit)
        try:
            self.state = 1621
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1619
                self.secondary_unit()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1620
                self.primary_unit()
                pass


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


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NULL_(self):
            return self.getToken(vhdlParser.NULL_, 0)

        def BIT_STRING_LITERAL(self):
            return self.getToken(vhdlParser.BIT_STRING_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def enumeration_literal(self):
            return self.getTypedRuleContext(vhdlParser.Enumeration_literalContext,0)


        def numeric_literal(self):
            return self.getTypedRuleContext(vhdlParser.Numeric_literalContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_literal

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

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

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




    def literal(self):

        localctx = vhdlParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_literal)
        try:
            self.state = 1628
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.NULL_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1623
                self.match(vhdlParser.NULL_)
                pass
            elif token in [vhdlParser.BIT_STRING_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1624
                self.match(vhdlParser.BIT_STRING_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1625
                self.match(vhdlParser.STRING_LITERAL)
                pass
            elif token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1626
                self.enumeration_literal()
                pass
            elif token in [vhdlParser.BASE_LITERAL, vhdlParser.REAL_LITERAL, vhdlParser.INTEGER]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1627
                self.numeric_literal()
                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 Logical_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_logical_name

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

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

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




    def logical_name(self):

        localctx = vhdlParser.Logical_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_logical_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1630
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Logical_name_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def logical_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Logical_nameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Logical_nameContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_logical_name_list

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

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

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




    def logical_name_list(self):

        localctx = vhdlParser.Logical_name_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_logical_name_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1632
            self.logical_name()
            self.state = 1637
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1633
                self.match(vhdlParser.COMMA)
                self.state = 1634
                self.logical_name()
                self.state = 1639
                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 Logical_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AND(self):
            return self.getToken(vhdlParser.AND, 0)

        def OR(self):
            return self.getToken(vhdlParser.OR, 0)

        def NAND(self):
            return self.getToken(vhdlParser.NAND, 0)

        def NOR(self):
            return self.getToken(vhdlParser.NOR, 0)

        def XOR(self):
            return self.getToken(vhdlParser.XOR, 0)

        def XNOR(self):
            return self.getToken(vhdlParser.XNOR, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_logical_operator

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

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

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




    def logical_operator(self):

        localctx = vhdlParser.Logical_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_logical_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1640
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.AND) | (1 << vhdlParser.NAND) | (1 << vhdlParser.NOR) | (1 << vhdlParser.OR))) != 0) or _la==vhdlParser.XNOR or _la==vhdlParser.XOR):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Loop_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def sequence_of_statements(self):
            return self.getTypedRuleContext(vhdlParser.Sequence_of_statementsContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def iteration_scheme(self):
            return self.getTypedRuleContext(vhdlParser.Iteration_schemeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_loop_statement

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

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

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




    def loop_statement(self):

        localctx = vhdlParser.Loop_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_loop_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1642
                self.label_colon()


            self.state = 1646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR or _la==vhdlParser.WHILE:
                self.state = 1645
                self.iteration_scheme()


            self.state = 1648
            self.match(vhdlParser.LOOP)
            self.state = 1649
            self.sequence_of_statements()
            self.state = 1650
            self.match(vhdlParser.END)
            self.state = 1651
            self.match(vhdlParser.LOOP)
            self.state = 1653
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1652
                self.identifier()


            self.state = 1655
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signal_modeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IN(self):
            return self.getToken(vhdlParser.IN, 0)

        def OUT(self):
            return self.getToken(vhdlParser.OUT, 0)

        def INOUT(self):
            return self.getToken(vhdlParser.INOUT, 0)

        def BUFFER(self):
            return self.getToken(vhdlParser.BUFFER, 0)

        def LINKAGE(self):
            return self.getToken(vhdlParser.LINKAGE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_signal_mode

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

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

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




    def signal_mode(self):

        localctx = vhdlParser.Signal_modeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_signal_mode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1657
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.BUFFER) | (1 << vhdlParser.IN) | (1 << vhdlParser.INOUT) | (1 << vhdlParser.LINKAGE) | (1 << vhdlParser.OUT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Multiplying_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MUL(self):
            return self.getToken(vhdlParser.MUL, 0)

        def DIV(self):
            return self.getToken(vhdlParser.DIV, 0)

        def MOD(self):
            return self.getToken(vhdlParser.MOD, 0)

        def REM(self):
            return self.getToken(vhdlParser.REM, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_multiplying_operator

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

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

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




    def multiplying_operator(self):

        localctx = vhdlParser.Multiplying_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_multiplying_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1659
            _la = self._input.LA(1)
            if not(_la==vhdlParser.MOD or _la==vhdlParser.REM or _la==vhdlParser.MUL or _la==vhdlParser.DIV):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def name_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Name_partContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Name_partContext,i)


        def getRuleIndex(self):
            return vhdlParser.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 = vhdlParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1663
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.state = 1661
                self.identifier()
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.state = 1662
                self.match(vhdlParser.STRING_LITERAL)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1668
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,169,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1665
                    self.name_part() 
                self.state = 1670
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,169,self._ctx)

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


    class Name_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def selected_name_part(self):
            return self.getTypedRuleContext(vhdlParser.Selected_name_partContext,0)


        def function_call_or_indexed_name_part(self):
            return self.getTypedRuleContext(vhdlParser.Function_call_or_indexed_name_partContext,0)


        def slice_name_part(self):
            return self.getTypedRuleContext(vhdlParser.Slice_name_partContext,0)


        def attribute_name_part(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_name_partContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_name_part

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

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

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




    def name_part(self):

        localctx = vhdlParser.Name_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_name_part)
        try:
            self.state = 1675
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1671
                self.selected_name_part()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1672
                self.function_call_or_indexed_name_part()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1673
                self.slice_name_part()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1674
                self.attribute_name_part()
                pass


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


    class Selected_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


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

        def suffix(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.SuffixContext)
            else:
                return self.getTypedRuleContext(vhdlParser.SuffixContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_selected_name

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

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

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




    def selected_name(self):

        localctx = vhdlParser.Selected_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_selected_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1677
            self.identifier()
            self.state = 1682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.DOT:
                self.state = 1678
                self.match(vhdlParser.DOT)
                self.state = 1679
                self.suffix()
                self.state = 1684
                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 Selected_name_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def suffix(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.SuffixContext)
            else:
                return self.getTypedRuleContext(vhdlParser.SuffixContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_selected_name_part

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

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

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




    def selected_name_part(self):

        localctx = vhdlParser.Selected_name_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_selected_name_part)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1687 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1685
                    self.match(vhdlParser.DOT)
                    self.state = 1686
                    self.suffix()

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

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


    class Function_call_or_indexed_name_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def actual_parameter_part(self):
            return self.getTypedRuleContext(vhdlParser.Actual_parameter_partContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_function_call_or_indexed_name_part

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

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

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




    def function_call_or_indexed_name_part(self):

        localctx = vhdlParser.Function_call_or_indexed_name_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_function_call_or_indexed_name_part)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1691
            self.match(vhdlParser.LPAREN)
            self.state = 1692
            self.actual_parameter_part()
            self.state = 1693
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Slice_name_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def discrete_range(self):
            return self.getTypedRuleContext(vhdlParser.Discrete_rangeContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_slice_name_part

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

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

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




    def slice_name_part(self):

        localctx = vhdlParser.Slice_name_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_slice_name_part)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1695
            self.match(vhdlParser.LPAREN)
            self.state = 1696
            self.discrete_range()
            self.state = 1697
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_name_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def APOSTROPHE(self):
            return self.getToken(vhdlParser.APOSTROPHE, 0)

        def attribute_designator(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_designatorContext,0)


        def signature(self):
            return self.getTypedRuleContext(vhdlParser.SignatureContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_attribute_name_part

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

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

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




    def attribute_name_part(self):

        localctx = vhdlParser.Attribute_name_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_attribute_name_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LBRACKET:
                self.state = 1699
                self.signature()


            self.state = 1702
            self.match(vhdlParser.APOSTROPHE)
            self.state = 1703
            self.attribute_designator()
            self.state = 1708
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                self.state = 1704
                self.match(vhdlParser.LPAREN)
                self.state = 1705
                self.expression()
                self.state = 1706
                self.match(vhdlParser.RPAREN)


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


    class Nature_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NATURE(self):
            return self.getToken(vhdlParser.NATURE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Nature_definitionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_nature_declaration

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

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

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




    def nature_declaration(self):

        localctx = vhdlParser.Nature_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_nature_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1710
            self.match(vhdlParser.NATURE)
            self.state = 1711
            self.identifier()
            self.state = 1712
            self.match(vhdlParser.IS)
            self.state = 1713
            self.nature_definition()
            self.state = 1714
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def scalar_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Scalar_nature_definitionContext,0)


        def composite_nature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Composite_nature_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_nature_definition

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

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

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




    def nature_definition(self):

        localctx = vhdlParser.Nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_nature_definition)
        try:
            self.state = 1718
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1716
                self.scalar_nature_definition()
                pass
            elif token in [vhdlParser.ARRAY, vhdlParser.RECORD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1717
                self.composite_nature_definition()
                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 Nature_element_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def element_subnature_definition(self):
            return self.getTypedRuleContext(vhdlParser.Element_subnature_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_nature_element_declaration

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

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

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




    def nature_element_declaration(self):

        localctx = vhdlParser.Nature_element_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_nature_element_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1720
            self.identifier_list()
            self.state = 1721
            self.match(vhdlParser.COLON)
            self.state = 1722
            self.element_subnature_definition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Next_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def condition(self):
            return self.getTypedRuleContext(vhdlParser.ConditionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_next_statement

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

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

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




    def next_statement(self):

        localctx = vhdlParser.Next_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_next_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1724
                self.label_colon()


            self.state = 1727
            self.match(vhdlParser.NEXT)
            self.state = 1729
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1728
                self.identifier()


            self.state = 1733
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.WHEN:
                self.state = 1731
                self.match(vhdlParser.WHEN)
                self.state = 1732
                self.condition()


            self.state = 1735
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Numeric_literalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def abstract_literal(self):
            return self.getTypedRuleContext(vhdlParser.Abstract_literalContext,0)


        def physical_literal(self):
            return self.getTypedRuleContext(vhdlParser.Physical_literalContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_numeric_literal

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

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

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




    def numeric_literal(self):

        localctx = vhdlParser.Numeric_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_numeric_literal)
        try:
            self.state = 1739
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1737
                self.abstract_literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1738
                self.physical_literal()
                pass


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


    class Object_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def signal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Signal_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def terminal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Terminal_declarationContext,0)


        def quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Quantity_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_object_declaration

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

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

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




    def object_declaration(self):

        localctx = vhdlParser.Object_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_object_declaration)
        try:
            self.state = 1747
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.CONSTANT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1741
                self.constant_declaration()
                pass
            elif token in [vhdlParser.SIGNAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1742
                self.signal_declaration()
                pass
            elif token in [vhdlParser.SHARED, vhdlParser.VARIABLE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1743
                self.variable_declaration()
                pass
            elif token in [vhdlParser.FILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1744
                self.file_declaration()
                pass
            elif token in [vhdlParser.TERMINAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1745
                self.terminal_declaration()
                pass
            elif token in [vhdlParser.QUANTITY]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1746
                self.quantity_declaration()
                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 OptsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GUARDED(self):
            return self.getToken(vhdlParser.GUARDED, 0)

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_opts

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

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

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




    def opts(self):

        localctx = vhdlParser.OptsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_opts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1750
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.GUARDED:
                self.state = 1749
                self.match(vhdlParser.GUARDED)


            self.state = 1753
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (vhdlParser.INERTIAL - 39)) | (1 << (vhdlParser.REJECT - 39)) | (1 << (vhdlParser.TRANSPORT - 39)))) != 0):
                self.state = 1752
                self.delay_mechanism()


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


    class Package_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def package_body_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Package_body_declarative_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_package_body

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

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

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




    def package_body(self):

        localctx = vhdlParser.Package_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_package_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1755
            self.match(vhdlParser.PACKAGE)
            self.state = 1756
            self.match(vhdlParser.BODY)
            self.state = 1757
            self.identifier()
            self.state = 1758
            self.match(vhdlParser.IS)
            self.state = 1759
            self.package_body_declarative_part()
            self.state = 1760
            self.match(vhdlParser.END)
            self.state = 1763
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PACKAGE:
                self.state = 1761
                self.match(vhdlParser.PACKAGE)
                self.state = 1762
                self.match(vhdlParser.BODY)


            self.state = 1766
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1765
                self.identifier()


            self.state = 1768
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Package_body_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_package_body_declarative_item

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

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

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




    def package_body_declarative_item(self):

        localctx = vhdlParser.Package_body_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_package_body_declarative_item)
        try:
            self.state = 1781
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1770
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1771
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1772
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1773
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1774
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1775
                self.variable_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1776
                self.file_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1777
                self.alias_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1778
                self.use_clause()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1779
                self.group_template_declaration()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1780
                self.group_declaration()
                pass


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


    class Package_body_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def package_body_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Package_body_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Package_body_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_package_body_declarative_part

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

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

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




    def package_body_declarative_part(self):

        localctx = vhdlParser.Package_body_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_package_body_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1786
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1783
                self.package_body_declarative_item()
                self.state = 1788
                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 Package_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def package_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Package_declarative_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_package_declaration

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

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

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




    def package_declaration(self):

        localctx = vhdlParser.Package_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_package_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1789
            self.match(vhdlParser.PACKAGE)
            self.state = 1790
            self.identifier()
            self.state = 1791
            self.match(vhdlParser.IS)
            self.state = 1792
            self.package_declarative_part()
            self.state = 1793
            self.match(vhdlParser.END)
            self.state = 1795
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PACKAGE:
                self.state = 1794
                self.match(vhdlParser.PACKAGE)


            self.state = 1798
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1797
                self.identifier()


            self.state = 1800
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Package_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def signal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Signal_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def component_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Component_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def disconnection_specification(self):
            return self.getTypedRuleContext(vhdlParser.Disconnection_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def nature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Nature_declarationContext,0)


        def subnature_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_declarationContext,0)


        def terminal_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Terminal_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_package_declarative_item

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

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

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




    def package_declarative_item(self):

        localctx = vhdlParser.Package_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_package_declarative_item)
        try:
            self.state = 1821
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1802
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1803
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1804
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1805
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1806
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1807
                self.signal_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1808
                self.variable_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1809
                self.file_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1810
                self.alias_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1811
                self.component_declaration()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1812
                self.attribute_declaration()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1813
                self.attribute_specification()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1814
                self.disconnection_specification()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1815
                self.use_clause()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1816
                self.group_template_declaration()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1817
                self.group_declaration()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1818
                self.nature_declaration()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1819
                self.subnature_declaration()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1820
                self.terminal_declaration()
                pass


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


    class Package_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def package_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Package_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Package_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_package_declarative_part

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

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

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




    def package_declarative_part(self):

        localctx = vhdlParser.Package_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_package_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.COMPONENT) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.DISCONNECT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE) | (1 << vhdlParser.NATURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SIGNAL - 68)) | (1 << (vhdlParser.SUBNATURE - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TERMINAL - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1823
                self.package_declarative_item()
                self.state = 1828
                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 Parameter_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def IN(self):
            return self.getToken(vhdlParser.IN, 0)

        def discrete_range(self):
            return self.getTypedRuleContext(vhdlParser.Discrete_rangeContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_parameter_specification

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

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

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




    def parameter_specification(self):

        localctx = vhdlParser.Parameter_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_parameter_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            self.identifier()
            self.state = 1830
            self.match(vhdlParser.IN)
            self.state = 1831
            self.discrete_range()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Physical_literalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def abstract_literal(self):
            return self.getTypedRuleContext(vhdlParser.Abstract_literalContext,0)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_physical_literal

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

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

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




    def physical_literal(self):

        localctx = vhdlParser.Physical_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_physical_literal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1833
            self.abstract_literal()

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


    class Physical_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def range_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Range_constraintContext,0)


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

        def base_unit_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Base_unit_declarationContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def secondary_unit_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Secondary_unit_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Secondary_unit_declarationContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_physical_type_definition

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

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

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




    def physical_type_definition(self):

        localctx = vhdlParser.Physical_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_physical_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1836
            self.range_constraint()
            self.state = 1837
            self.match(vhdlParser.UNITS)
            self.state = 1838
            self.base_unit_declaration()
            self.state = 1842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1839
                self.secondary_unit_declaration()
                self.state = 1844
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1845
            self.match(vhdlParser.END)
            self.state = 1846
            self.match(vhdlParser.UNITS)
            self.state = 1848
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1847
                self.identifier()


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


    class Port_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PORT(self):
            return self.getToken(vhdlParser.PORT, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def port_list(self):
            return self.getTypedRuleContext(vhdlParser.Port_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_port_clause

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

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

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




    def port_clause(self):

        localctx = vhdlParser.Port_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_port_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1850
            self.match(vhdlParser.PORT)
            self.state = 1851
            self.match(vhdlParser.LPAREN)
            self.state = 1852
            self.port_list()
            self.state = 1853
            self.match(vhdlParser.RPAREN)
            self.state = 1854
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Port_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interface_port_list(self):
            return self.getTypedRuleContext(vhdlParser.Interface_port_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_port_list

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

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

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




    def port_list(self):

        localctx = vhdlParser.Port_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_port_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1856
            self.interface_port_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Port_map_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PORT(self):
            return self.getToken(vhdlParser.PORT, 0)

        def MAP(self):
            return self.getToken(vhdlParser.MAP, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def association_list(self):
            return self.getTypedRuleContext(vhdlParser.Association_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_port_map_aspect

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

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

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




    def port_map_aspect(self):

        localctx = vhdlParser.Port_map_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_port_map_aspect)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1858
            self.match(vhdlParser.PORT)
            self.state = 1859
            self.match(vhdlParser.MAP)
            self.state = 1860
            self.match(vhdlParser.LPAREN)
            self.state = 1861
            self.association_list()
            self.state = 1862
            self.match(vhdlParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def literal(self):
            return self.getTypedRuleContext(vhdlParser.LiteralContext,0)


        def qualified_expression(self):
            return self.getTypedRuleContext(vhdlParser.Qualified_expressionContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def allocator(self):
            return self.getTypedRuleContext(vhdlParser.AllocatorContext,0)


        def aggregate(self):
            return self.getTypedRuleContext(vhdlParser.AggregateContext,0)


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


        def getRuleIndex(self):
            return vhdlParser.RULE_primary

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

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

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




    def primary(self):

        localctx = vhdlParser.PrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_primary)
        try:
            self.state = 1873
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1864
                self.literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1865
                self.qualified_expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1866
                self.match(vhdlParser.LPAREN)
                self.state = 1867
                self.expression()
                self.state = 1868
                self.match(vhdlParser.RPAREN)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1870
                self.allocator()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1871
                self.aggregate()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1872
                self.name()
                pass


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


    class Primary_unitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def entity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Entity_declarationContext,0)


        def configuration_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Configuration_declarationContext,0)


        def package_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Package_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_primary_unit

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

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

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




    def primary_unit(self):

        localctx = vhdlParser.Primary_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_primary_unit)
        try:
            self.state = 1878
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ENTITY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1875
                self.entity_declaration()
                pass
            elif token in [vhdlParser.CONFIGURATION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1876
                self.configuration_declaration()
                pass
            elif token in [vhdlParser.PACKAGE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1877
                self.package_declaration()
                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 Procedural_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_procedural_declarative_item

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

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

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




    def procedural_declarative_item(self):

        localctx = vhdlParser.Procedural_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_procedural_declarative_item)
        try:
            self.state = 1892
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1880
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1881
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1882
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1883
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1884
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1885
                self.variable_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1886
                self.alias_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1887
                self.attribute_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1888
                self.attribute_specification()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1889
                self.use_clause()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1890
                self.group_template_declaration()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1891
                self.group_declaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Procedural_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def procedural_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Procedural_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Procedural_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_procedural_declarative_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcedural_declarative_part" ):
                listener.enterProcedural_declarative_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcedural_declarative_part" ):
                listener.exitProcedural_declarative_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcedural_declarative_part" ):
                return visitor.visitProcedural_declarative_part(self)
            else:
                return visitor.visitChildren(self)




    def procedural_declarative_part(self):

        localctx = vhdlParser.Procedural_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_procedural_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1897
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1894
                self.procedural_declarative_item()
                self.state = 1899
                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 Procedural_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sequential_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Sequential_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Sequential_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_procedural_statement_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcedural_statement_part" ):
                listener.enterProcedural_statement_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcedural_statement_part" ):
                listener.exitProcedural_statement_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcedural_statement_part" ):
                return visitor.visitProcedural_statement_part(self)
            else:
                return visitor.visitChildren(self)




    def procedural_statement_part(self):

        localctx = vhdlParser.Procedural_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_procedural_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1903
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.EXIT) | (1 << vhdlParser.FOR) | (1 << vhdlParser.IF) | (1 << vhdlParser.LOOP) | (1 << vhdlParser.NEXT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (vhdlParser.REPORT - 79)) | (1 << (vhdlParser.RETURN - 79)) | (1 << (vhdlParser.WAIT - 79)) | (1 << (vhdlParser.WHILE - 79)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 79)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 79)) | (1 << (vhdlParser.STRING_LITERAL - 79)) | (1 << (vhdlParser.LPAREN - 79)))) != 0):
                self.state = 1900
                self.sequential_statement()
                self.state = 1905
                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 Procedure_callContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def selected_name(self):
            return self.getTypedRuleContext(vhdlParser.Selected_nameContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def actual_parameter_part(self):
            return self.getTypedRuleContext(vhdlParser.Actual_parameter_partContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_procedure_call

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcedure_call" ):
                listener.enterProcedure_call(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcedure_call" ):
                listener.exitProcedure_call(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcedure_call" ):
                return visitor.visitProcedure_call(self)
            else:
                return visitor.visitChildren(self)




    def procedure_call(self):

        localctx = vhdlParser.Procedure_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_procedure_call)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1906
            self.selected_name()
            self.state = 1911
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 1907
                self.match(vhdlParser.LPAREN)
                self.state = 1908
                self.actual_parameter_part()
                self.state = 1909
                self.match(vhdlParser.RPAREN)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Procedure_call_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def procedure_call(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_callContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_procedure_call_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcedure_call_statement" ):
                listener.enterProcedure_call_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcedure_call_statement" ):
                listener.exitProcedure_call_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcedure_call_statement" ):
                return visitor.visitProcedure_call_statement(self)
            else:
                return visitor.visitChildren(self)




    def procedure_call_statement(self):

        localctx = vhdlParser.Procedure_call_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_procedure_call_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1914
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
            if la_ == 1:
                self.state = 1913
                self.label_colon()


            self.state = 1916
            self.procedure_call()
            self.state = 1917
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Process_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_process_declarative_item

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcess_declarative_item" ):
                listener.enterProcess_declarative_item(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcess_declarative_item" ):
                listener.exitProcess_declarative_item(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcess_declarative_item" ):
                return visitor.visitProcess_declarative_item(self)
            else:
                return visitor.visitChildren(self)




    def process_declarative_item(self):

        localctx = vhdlParser.Process_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_process_declarative_item)
        try:
            self.state = 1932
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1919
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1920
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1921
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1922
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1923
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1924
                self.variable_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1925
                self.file_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1926
                self.alias_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1927
                self.attribute_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1928
                self.attribute_specification()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1929
                self.use_clause()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1930
                self.group_template_declaration()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1931
                self.group_declaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Process_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def process_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Process_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Process_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_process_declarative_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcess_declarative_part" ):
                listener.enterProcess_declarative_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcess_declarative_part" ):
                listener.exitProcess_declarative_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcess_declarative_part" ):
                return visitor.visitProcess_declarative_part(self)
            else:
                return visitor.visitChildren(self)




    def process_declarative_part(self):

        localctx = vhdlParser.Process_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_process_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1937
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 1934
                self.process_declarative_item()
                self.state = 1939
                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 Process_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROCESS(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.PROCESS)
            else:
                return self.getToken(vhdlParser.PROCESS, i)

        def process_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Process_declarative_partContext,0)


        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def process_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Process_statement_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def POSTPONED(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.POSTPONED)
            else:
                return self.getToken(vhdlParser.POSTPONED, i)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def sensitivity_list(self):
            return self.getTypedRuleContext(vhdlParser.Sensitivity_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_process_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcess_statement" ):
                listener.enterProcess_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcess_statement" ):
                listener.exitProcess_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcess_statement" ):
                return visitor.visitProcess_statement(self)
            else:
                return visitor.visitChildren(self)




    def process_statement(self):

        localctx = vhdlParser.Process_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_process_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1941
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1940
                self.label_colon()


            self.state = 1944
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.POSTPONED:
                self.state = 1943
                self.match(vhdlParser.POSTPONED)


            self.state = 1946
            self.match(vhdlParser.PROCESS)
            self.state = 1951
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 1947
                self.match(vhdlParser.LPAREN)
                self.state = 1948
                self.sensitivity_list()
                self.state = 1949
                self.match(vhdlParser.RPAREN)


            self.state = 1954
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS:
                self.state = 1953
                self.match(vhdlParser.IS)


            self.state = 1956
            self.process_declarative_part()
            self.state = 1957
            self.match(vhdlParser.BEGIN)
            self.state = 1958
            self.process_statement_part()
            self.state = 1959
            self.match(vhdlParser.END)
            self.state = 1961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.POSTPONED:
                self.state = 1960
                self.match(vhdlParser.POSTPONED)


            self.state = 1963
            self.match(vhdlParser.PROCESS)
            self.state = 1965
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1964
                self.identifier()


            self.state = 1967
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Process_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sequential_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Sequential_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Sequential_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_process_statement_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcess_statement_part" ):
                listener.enterProcess_statement_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcess_statement_part" ):
                listener.exitProcess_statement_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcess_statement_part" ):
                return visitor.visitProcess_statement_part(self)
            else:
                return visitor.visitChildren(self)




    def process_statement_part(self):

        localctx = vhdlParser.Process_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_process_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1972
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.EXIT) | (1 << vhdlParser.FOR) | (1 << vhdlParser.IF) | (1 << vhdlParser.LOOP) | (1 << vhdlParser.NEXT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (vhdlParser.REPORT - 79)) | (1 << (vhdlParser.RETURN - 79)) | (1 << (vhdlParser.WAIT - 79)) | (1 << (vhdlParser.WHILE - 79)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 79)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 79)) | (1 << (vhdlParser.STRING_LITERAL - 79)) | (1 << (vhdlParser.LPAREN - 79)))) != 0):
                self.state = 1969
                self.sequential_statement()
                self.state = 1974
                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 Qualified_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def APOSTROPHE(self):
            return self.getToken(vhdlParser.APOSTROPHE, 0)

        def aggregate(self):
            return self.getTypedRuleContext(vhdlParser.AggregateContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_qualified_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualified_expression" ):
                listener.enterQualified_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualified_expression" ):
                listener.exitQualified_expression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualified_expression" ):
                return visitor.visitQualified_expression(self)
            else:
                return visitor.visitChildren(self)




    def qualified_expression(self):

        localctx = vhdlParser.Qualified_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_qualified_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1975
            self.subtype_indication()
            self.state = 1976
            self.match(vhdlParser.APOSTROPHE)
            self.state = 1982
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 1977
                self.aggregate()
                pass

            elif la_ == 2:
                self.state = 1978
                self.match(vhdlParser.LPAREN)
                self.state = 1979
                self.expression()
                self.state = 1980
                self.match(vhdlParser.RPAREN)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Quantity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def free_quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Free_quantity_declarationContext,0)


        def branch_quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Branch_quantity_declarationContext,0)


        def source_quantity_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Source_quantity_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_quantity_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantity_declaration" ):
                listener.enterQuantity_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantity_declaration" ):
                listener.exitQuantity_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantity_declaration" ):
                return visitor.visitQuantity_declaration(self)
            else:
                return visitor.visitChildren(self)




    def quantity_declaration(self):

        localctx = vhdlParser.Quantity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_quantity_declaration)
        try:
            self.state = 1987
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1984
                self.free_quantity_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1985
                self.branch_quantity_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1986
                self.source_quantity_declaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Quantity_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def OTHERS(self):
            return self.getToken(vhdlParser.OTHERS, 0)

        def ALL(self):
            return self.getToken(vhdlParser.ALL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_quantity_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantity_list" ):
                listener.enterQuantity_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantity_list" ):
                listener.exitQuantity_list(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantity_list" ):
                return visitor.visitQuantity_list(self)
            else:
                return visitor.visitChildren(self)




    def quantity_list(self):

        localctx = vhdlParser.Quantity_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_quantity_list)
        self._la = 0 # Token type
        try:
            self.state = 1999
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1989
                self.name()
                self.state = 1994
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1990
                    self.match(vhdlParser.COMMA)
                    self.state = 1991
                    self.name()
                    self.state = 1996
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1997
                self.match(vhdlParser.OTHERS)
                pass
            elif token in [vhdlParser.ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1998
                self.match(vhdlParser.ALL)
                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 Quantity_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def quantity_list(self):
            return self.getTypedRuleContext(vhdlParser.Quantity_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def name(self):
            return self.getTypedRuleContext(vhdlParser.NameContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_quantity_specification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantity_specification" ):
                listener.enterQuantity_specification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantity_specification" ):
                listener.exitQuantity_specification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantity_specification" ):
                return visitor.visitQuantity_specification(self)
            else:
                return visitor.visitChildren(self)




    def quantity_specification(self):

        localctx = vhdlParser.Quantity_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_quantity_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2001
            self.quantity_list()
            self.state = 2002
            self.match(vhdlParser.COLON)
            self.state = 2003
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Range_declContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def explicit_range(self):
            return self.getTypedRuleContext(vhdlParser.Explicit_rangeContext,0)


        def name(self):
            return self.getTypedRuleContext(vhdlParser.NameContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_range_decl

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRange_decl" ):
                listener.enterRange_decl(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRange_decl" ):
                listener.exitRange_decl(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRange_decl" ):
                return visitor.visitRange_decl(self)
            else:
                return visitor.visitChildren(self)




    def range_decl(self):

        localctx = vhdlParser.Range_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_range_decl)
        try:
            self.state = 2007
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2005
                self.explicit_range()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2006
                self.name()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Explicit_rangeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simple_expressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,i)


        def direction(self):
            return self.getTypedRuleContext(vhdlParser.DirectionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_explicit_range

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicit_range" ):
                listener.enterExplicit_range(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicit_range" ):
                listener.exitExplicit_range(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplicit_range" ):
                return visitor.visitExplicit_range(self)
            else:
                return visitor.visitChildren(self)




    def explicit_range(self):

        localctx = vhdlParser.Explicit_rangeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_explicit_range)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2009
            self.simple_expression()
            self.state = 2013
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
            if la_ == 1:
                self.state = 2010
                self.direction()
                self.state = 2011
                self.simple_expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Range_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RANGE(self):
            return self.getToken(vhdlParser.RANGE, 0)

        def range_decl(self):
            return self.getTypedRuleContext(vhdlParser.Range_declContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_range_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRange_constraint" ):
                listener.enterRange_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRange_constraint" ):
                listener.exitRange_constraint(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRange_constraint" ):
                return visitor.visitRange_constraint(self)
            else:
                return visitor.visitChildren(self)




    def range_constraint(self):

        localctx = vhdlParser.Range_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_range_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2015
            self.match(vhdlParser.RANGE)
            self.state = 2016
            self.range_decl()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Record_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RECORD(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.RECORD)
            else:
                return self.getToken(vhdlParser.RECORD, i)

        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def nature_element_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Nature_element_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Nature_element_declarationContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_record_nature_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRecord_nature_definition" ):
                listener.enterRecord_nature_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRecord_nature_definition" ):
                listener.exitRecord_nature_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRecord_nature_definition" ):
                return visitor.visitRecord_nature_definition(self)
            else:
                return visitor.visitChildren(self)




    def record_nature_definition(self):

        localctx = vhdlParser.Record_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_record_nature_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.match(vhdlParser.RECORD)
            self.state = 2020 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2019
                self.nature_element_declaration()
                self.state = 2022 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER):
                    break

            self.state = 2024
            self.match(vhdlParser.END)
            self.state = 2025
            self.match(vhdlParser.RECORD)
            self.state = 2027
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2026
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Record_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RECORD(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.RECORD)
            else:
                return self.getToken(vhdlParser.RECORD, i)

        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def element_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Element_declarationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Element_declarationContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_record_type_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRecord_type_definition" ):
                listener.enterRecord_type_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRecord_type_definition" ):
                listener.exitRecord_type_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRecord_type_definition" ):
                return visitor.visitRecord_type_definition(self)
            else:
                return visitor.visitChildren(self)




    def record_type_definition(self):

        localctx = vhdlParser.Record_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_record_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2029
            self.match(vhdlParser.RECORD)
            self.state = 2031 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2030
                self.element_declaration()
                self.state = 2033 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER):
                    break

            self.state = 2035
            self.match(vhdlParser.END)
            self.state = 2036
            self.match(vhdlParser.RECORD)
            self.state = 2038
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2037
                self.identifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def shift_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Shift_expressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Shift_expressionContext,i)


        def relational_operator(self):
            return self.getTypedRuleContext(vhdlParser.Relational_operatorContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_relation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelation" ):
                listener.enterRelation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelation" ):
                listener.exitRelation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelation" ):
                return visitor.visitRelation(self)
            else:
                return visitor.visitChildren(self)




    def relation(self):

        localctx = vhdlParser.RelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_relation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2040
            self.shift_expression()
            self.state = 2044
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
            if la_ == 1:
                self.state = 2041
                self.relational_operator()
                self.state = 2042
                self.shift_expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Relational_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQ(self):
            return self.getToken(vhdlParser.EQ, 0)

        def NEQ(self):
            return self.getToken(vhdlParser.NEQ, 0)

        def LOWERTHAN(self):
            return self.getToken(vhdlParser.LOWERTHAN, 0)

        def LE(self):
            return self.getToken(vhdlParser.LE, 0)

        def GREATERTHAN(self):
            return self.getToken(vhdlParser.GREATERTHAN, 0)

        def GE(self):
            return self.getToken(vhdlParser.GE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_relational_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelational_operator" ):
                listener.enterRelational_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelational_operator" ):
                listener.exitRelational_operator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelational_operator" ):
                return visitor.visitRelational_operator(self)
            else:
                return visitor.visitChildren(self)




    def relational_operator(self):

        localctx = vhdlParser.Relational_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_relational_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2046
            _la = self._input.LA(1)
            if not(((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (vhdlParser.LE - 131)) | (1 << (vhdlParser.GE - 131)) | (1 << (vhdlParser.NEQ - 131)) | (1 << (vhdlParser.LOWERTHAN - 131)) | (1 << (vhdlParser.GREATERTHAN - 131)) | (1 << (vhdlParser.EQ - 131)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Report_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REPORT(self):
            return self.getToken(vhdlParser.REPORT, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ExpressionContext,i)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def SEVERITY(self):
            return self.getToken(vhdlParser.SEVERITY, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_report_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReport_statement" ):
                listener.enterReport_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReport_statement" ):
                listener.exitReport_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReport_statement" ):
                return visitor.visitReport_statement(self)
            else:
                return visitor.visitChildren(self)




    def report_statement(self):

        localctx = vhdlParser.Report_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_report_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2049
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2048
                self.label_colon()


            self.state = 2051
            self.match(vhdlParser.REPORT)
            self.state = 2052
            self.expression()
            self.state = 2055
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.SEVERITY:
                self.state = 2053
                self.match(vhdlParser.SEVERITY)
                self.state = 2054
                self.expression()


            self.state = 2057
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RETURN(self):
            return self.getToken(vhdlParser.RETURN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_return_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturn_statement" ):
                listener.enterReturn_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturn_statement" ):
                listener.exitReturn_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturn_statement" ):
                return visitor.visitReturn_statement(self)
            else:
                return visitor.visitChildren(self)




    def return_statement(self):

        localctx = vhdlParser.Return_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_return_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2060
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2059
                self.label_colon()


            self.state = 2062
            self.match(vhdlParser.RETURN)
            self.state = 2064
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ABS) | (1 << vhdlParser.NEW) | (1 << vhdlParser.NOT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 112)) & ~0x3f) == 0 and ((1 << (_la - 112)) & ((1 << (vhdlParser.BASE_LITERAL - 112)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 112)) | (1 << (vhdlParser.REAL_LITERAL - 112)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 112)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 112)) | (1 << (vhdlParser.CHARACTER_LITERAL - 112)) | (1 << (vhdlParser.STRING_LITERAL - 112)) | (1 << (vhdlParser.LPAREN - 112)) | (1 << (vhdlParser.PLUS - 112)) | (1 << (vhdlParser.MINUS - 112)) | (1 << (vhdlParser.INTEGER - 112)))) != 0):
                self.state = 2063
                self.expression()


            self.state = 2066
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Scalar_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def ACROSS(self):
            return self.getToken(vhdlParser.ACROSS, 0)

        def THROUGH(self):
            return self.getToken(vhdlParser.THROUGH, 0)

        def REFERENCE(self):
            return self.getToken(vhdlParser.REFERENCE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_scalar_nature_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterScalar_nature_definition" ):
                listener.enterScalar_nature_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitScalar_nature_definition" ):
                listener.exitScalar_nature_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitScalar_nature_definition" ):
                return visitor.visitScalar_nature_definition(self)
            else:
                return visitor.visitChildren(self)




    def scalar_nature_definition(self):

        localctx = vhdlParser.Scalar_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_scalar_nature_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2068
            self.name()
            self.state = 2069
            self.match(vhdlParser.ACROSS)
            self.state = 2070
            self.name()
            self.state = 2071
            self.match(vhdlParser.THROUGH)
            self.state = 2072
            self.name()
            self.state = 2073
            self.match(vhdlParser.REFERENCE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Scalar_type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def physical_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Physical_type_definitionContext,0)


        def enumeration_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Enumeration_type_definitionContext,0)


        def range_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Range_constraintContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_scalar_type_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterScalar_type_definition" ):
                listener.enterScalar_type_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitScalar_type_definition" ):
                listener.exitScalar_type_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitScalar_type_definition" ):
                return visitor.visitScalar_type_definition(self)
            else:
                return visitor.visitChildren(self)




    def scalar_type_definition(self):

        localctx = vhdlParser.Scalar_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_scalar_type_definition)
        try:
            self.state = 2078
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2075
                self.physical_type_definition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2076
                self.enumeration_type_definition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2077
                self.range_constraint()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Secondary_unitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def architecture_body(self):
            return self.getTypedRuleContext(vhdlParser.Architecture_bodyContext,0)


        def package_body(self):
            return self.getTypedRuleContext(vhdlParser.Package_bodyContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_secondary_unit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSecondary_unit" ):
                listener.enterSecondary_unit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSecondary_unit" ):
                listener.exitSecondary_unit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSecondary_unit" ):
                return visitor.visitSecondary_unit(self)
            else:
                return visitor.visitChildren(self)




    def secondary_unit(self):

        localctx = vhdlParser.Secondary_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_secondary_unit)
        try:
            self.state = 2082
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ARCHITECTURE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2080
                self.architecture_body()
                pass
            elif token in [vhdlParser.PACKAGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2081
                self.package_body()
                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 Secondary_unit_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def EQ(self):
            return self.getToken(vhdlParser.EQ, 0)

        def physical_literal(self):
            return self.getTypedRuleContext(vhdlParser.Physical_literalContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_secondary_unit_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSecondary_unit_declaration" ):
                listener.enterSecondary_unit_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSecondary_unit_declaration" ):
                listener.exitSecondary_unit_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSecondary_unit_declaration" ):
                return visitor.visitSecondary_unit_declaration(self)
            else:
                return visitor.visitChildren(self)




    def secondary_unit_declaration(self):

        localctx = vhdlParser.Secondary_unit_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_secondary_unit_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2084
            self.identifier()
            self.state = 2085
            self.match(vhdlParser.EQ)
            self.state = 2086
            self.physical_literal()
            self.state = 2087
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Selected_signal_assignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITH(self):
            return self.getToken(vhdlParser.WITH, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def SELECT(self):
            return self.getToken(vhdlParser.SELECT, 0)

        def target(self):
            return self.getTypedRuleContext(vhdlParser.TargetContext,0)


        def LE(self):
            return self.getToken(vhdlParser.LE, 0)

        def opts(self):
            return self.getTypedRuleContext(vhdlParser.OptsContext,0)


        def selected_waveforms(self):
            return self.getTypedRuleContext(vhdlParser.Selected_waveformsContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_selected_signal_assignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelected_signal_assignment" ):
                listener.enterSelected_signal_assignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelected_signal_assignment" ):
                listener.exitSelected_signal_assignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelected_signal_assignment" ):
                return visitor.visitSelected_signal_assignment(self)
            else:
                return visitor.visitChildren(self)




    def selected_signal_assignment(self):

        localctx = vhdlParser.Selected_signal_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_selected_signal_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2089
            self.match(vhdlParser.WITH)
            self.state = 2090
            self.expression()
            self.state = 2091
            self.match(vhdlParser.SELECT)
            self.state = 2092
            self.target()
            self.state = 2093
            self.match(vhdlParser.LE)
            self.state = 2094
            self.opts()
            self.state = 2095
            self.selected_waveforms()
            self.state = 2096
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Selected_waveformsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def waveform(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.WaveformContext)
            else:
                return self.getTypedRuleContext(vhdlParser.WaveformContext,i)


        def WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.WHEN)
            else:
                return self.getToken(vhdlParser.WHEN, i)

        def choices(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ChoicesContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ChoicesContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_selected_waveforms

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelected_waveforms" ):
                listener.enterSelected_waveforms(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelected_waveforms" ):
                listener.exitSelected_waveforms(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelected_waveforms" ):
                return visitor.visitSelected_waveforms(self)
            else:
                return visitor.visitChildren(self)




    def selected_waveforms(self):

        localctx = vhdlParser.Selected_waveformsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_selected_waveforms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2098
            self.waveform()
            self.state = 2099
            self.match(vhdlParser.WHEN)
            self.state = 2100
            self.choices()
            self.state = 2108
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2101
                self.match(vhdlParser.COMMA)
                self.state = 2102
                self.waveform()
                self.state = 2103
                self.match(vhdlParser.WHEN)
                self.state = 2104
                self.choices()
                self.state = 2110
                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 Sensitivity_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(vhdlParser.ON, 0)

        def sensitivity_list(self):
            return self.getTypedRuleContext(vhdlParser.Sensitivity_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_sensitivity_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSensitivity_clause" ):
                listener.enterSensitivity_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSensitivity_clause" ):
                listener.exitSensitivity_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSensitivity_clause" ):
                return visitor.visitSensitivity_clause(self)
            else:
                return visitor.visitChildren(self)




    def sensitivity_clause(self):

        localctx = vhdlParser.Sensitivity_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_sensitivity_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2111
            self.match(vhdlParser.ON)
            self.state = 2112
            self.sensitivity_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sensitivity_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_sensitivity_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSensitivity_list" ):
                listener.enterSensitivity_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSensitivity_list" ):
                listener.exitSensitivity_list(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSensitivity_list" ):
                return visitor.visitSensitivity_list(self)
            else:
                return visitor.visitChildren(self)




    def sensitivity_list(self):

        localctx = vhdlParser.Sensitivity_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_sensitivity_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2114
            self.name()
            self.state = 2119
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2115
                self.match(vhdlParser.COMMA)
                self.state = 2116
                self.name()
                self.state = 2121
                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 Sequence_of_statementsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sequential_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Sequential_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Sequential_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_sequence_of_statements

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSequence_of_statements" ):
                listener.enterSequence_of_statements(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSequence_of_statements" ):
                listener.exitSequence_of_statements(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSequence_of_statements" ):
                return visitor.visitSequence_of_statements(self)
            else:
                return visitor.visitChildren(self)




    def sequence_of_statements(self):

        localctx = vhdlParser.Sequence_of_statementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_sequence_of_statements)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2125
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.EXIT) | (1 << vhdlParser.FOR) | (1 << vhdlParser.IF) | (1 << vhdlParser.LOOP) | (1 << vhdlParser.NEXT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (vhdlParser.REPORT - 79)) | (1 << (vhdlParser.RETURN - 79)) | (1 << (vhdlParser.WAIT - 79)) | (1 << (vhdlParser.WHILE - 79)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 79)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 79)) | (1 << (vhdlParser.STRING_LITERAL - 79)) | (1 << (vhdlParser.LPAREN - 79)))) != 0):
                self.state = 2122
                self.sequential_statement()
                self.state = 2127
                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 Sequential_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def wait_statement(self):
            return self.getTypedRuleContext(vhdlParser.Wait_statementContext,0)


        def assertion_statement(self):
            return self.getTypedRuleContext(vhdlParser.Assertion_statementContext,0)


        def report_statement(self):
            return self.getTypedRuleContext(vhdlParser.Report_statementContext,0)


        def signal_assignment_statement(self):
            return self.getTypedRuleContext(vhdlParser.Signal_assignment_statementContext,0)


        def variable_assignment_statement(self):
            return self.getTypedRuleContext(vhdlParser.Variable_assignment_statementContext,0)


        def if_statement(self):
            return self.getTypedRuleContext(vhdlParser.If_statementContext,0)


        def case_statement(self):
            return self.getTypedRuleContext(vhdlParser.Case_statementContext,0)


        def loop_statement(self):
            return self.getTypedRuleContext(vhdlParser.Loop_statementContext,0)


        def next_statement(self):
            return self.getTypedRuleContext(vhdlParser.Next_statementContext,0)


        def exit_statement(self):
            return self.getTypedRuleContext(vhdlParser.Exit_statementContext,0)


        def return_statement(self):
            return self.getTypedRuleContext(vhdlParser.Return_statementContext,0)


        def NULL_(self):
            return self.getToken(vhdlParser.NULL_, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def break_statement(self):
            return self.getTypedRuleContext(vhdlParser.Break_statementContext,0)


        def procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_call_statementContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_sequential_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSequential_statement" ):
                listener.enterSequential_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSequential_statement" ):
                listener.exitSequential_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSequential_statement" ):
                return visitor.visitSequential_statement(self)
            else:
                return visitor.visitChildren(self)




    def sequential_statement(self):

        localctx = vhdlParser.Sequential_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 410, self.RULE_sequential_statement)
        self._la = 0 # Token type
        try:
            self.state = 2146
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2128
                self.wait_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2129
                self.assertion_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2130
                self.report_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2131
                self.signal_assignment_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2132
                self.variable_assignment_statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2133
                self.if_statement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2134
                self.case_statement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2135
                self.loop_statement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2136
                self.next_statement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2137
                self.exit_statement()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2138
                self.return_statement()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2140
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                    self.state = 2139
                    self.label_colon()


                self.state = 2142
                self.match(vhdlParser.NULL_)
                self.state = 2143
                self.match(vhdlParser.SEMI)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2144
                self.break_statement()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2145
                self.procedure_call_statement()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Shift_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simple_expressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,i)


        def shift_operator(self):
            return self.getTypedRuleContext(vhdlParser.Shift_operatorContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_shift_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShift_expression" ):
                listener.enterShift_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShift_expression" ):
                listener.exitShift_expression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShift_expression" ):
                return visitor.visitShift_expression(self)
            else:
                return visitor.visitChildren(self)




    def shift_expression(self):

        localctx = vhdlParser.Shift_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 412, self.RULE_shift_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2148
            self.simple_expression()
            self.state = 2152
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
            if la_ == 1:
                self.state = 2149
                self.shift_operator()
                self.state = 2150
                self.simple_expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Shift_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SLL(self):
            return self.getToken(vhdlParser.SLL, 0)

        def SRL(self):
            return self.getToken(vhdlParser.SRL, 0)

        def SLA(self):
            return self.getToken(vhdlParser.SLA, 0)

        def SRA(self):
            return self.getToken(vhdlParser.SRA, 0)

        def ROL(self):
            return self.getToken(vhdlParser.ROL, 0)

        def ROR(self):
            return self.getToken(vhdlParser.ROR, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_shift_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShift_operator" ):
                listener.enterShift_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShift_operator" ):
                listener.exitShift_operator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShift_operator" ):
                return visitor.visitShift_operator(self)
            else:
                return visitor.visitChildren(self)




    def shift_operator(self):

        localctx = vhdlParser.Shift_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 414, self.RULE_shift_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2154
            _la = self._input.LA(1)
            if not(((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (vhdlParser.ROL - 81)) | (1 << (vhdlParser.ROR - 81)) | (1 << (vhdlParser.SLA - 81)) | (1 << (vhdlParser.SLL - 81)) | (1 << (vhdlParser.SRA - 81)) | (1 << (vhdlParser.SRL - 81)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signal_assignment_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def target(self):
            return self.getTypedRuleContext(vhdlParser.TargetContext,0)


        def LE(self):
            return self.getToken(vhdlParser.LE, 0)

        def waveform(self):
            return self.getTypedRuleContext(vhdlParser.WaveformContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_signal_assignment_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignal_assignment_statement" ):
                listener.enterSignal_assignment_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignal_assignment_statement" ):
                listener.exitSignal_assignment_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignal_assignment_statement" ):
                return visitor.visitSignal_assignment_statement(self)
            else:
                return visitor.visitChildren(self)




    def signal_assignment_statement(self):

        localctx = vhdlParser.Signal_assignment_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 416, self.RULE_signal_assignment_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
            if la_ == 1:
                self.state = 2156
                self.label_colon()


            self.state = 2159
            self.target()
            self.state = 2160
            self.match(vhdlParser.LE)
            self.state = 2162
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (vhdlParser.INERTIAL - 39)) | (1 << (vhdlParser.REJECT - 39)) | (1 << (vhdlParser.TRANSPORT - 39)))) != 0):
                self.state = 2161
                self.delay_mechanism()


            self.state = 2164
            self.waveform()
            self.state = 2165
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signal_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SIGNAL(self):
            return self.getToken(vhdlParser.SIGNAL, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def signal_kind(self):
            return self.getTypedRuleContext(vhdlParser.Signal_kindContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_signal_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignal_declaration" ):
                listener.enterSignal_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignal_declaration" ):
                listener.exitSignal_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignal_declaration" ):
                return visitor.visitSignal_declaration(self)
            else:
                return visitor.visitChildren(self)




    def signal_declaration(self):

        localctx = vhdlParser.Signal_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 418, self.RULE_signal_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2167
            self.match(vhdlParser.SIGNAL)
            self.state = 2168
            self.identifier_list()
            self.state = 2169
            self.match(vhdlParser.COLON)
            self.state = 2170
            self.subtype_indication()
            self.state = 2172
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BUS or _la==vhdlParser.REGISTER:
                self.state = 2171
                self.signal_kind()


            self.state = 2176
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 2174
                self.match(vhdlParser.VARASGN)
                self.state = 2175
                self.expression()


            self.state = 2178
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signal_kindContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REGISTER(self):
            return self.getToken(vhdlParser.REGISTER, 0)

        def BUS(self):
            return self.getToken(vhdlParser.BUS, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_signal_kind

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignal_kind" ):
                listener.enterSignal_kind(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignal_kind" ):
                listener.exitSignal_kind(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignal_kind" ):
                return visitor.visitSignal_kind(self)
            else:
                return visitor.visitChildren(self)




    def signal_kind(self):

        localctx = vhdlParser.Signal_kindContext(self, self._ctx, self.state)
        self.enterRule(localctx, 420, self.RULE_signal_kind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2180
            _la = self._input.LA(1)
            if not(_la==vhdlParser.BUS or _la==vhdlParser.REGISTER):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signal_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def OTHERS(self):
            return self.getToken(vhdlParser.OTHERS, 0)

        def ALL(self):
            return self.getToken(vhdlParser.ALL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_signal_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignal_list" ):
                listener.enterSignal_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignal_list" ):
                listener.exitSignal_list(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignal_list" ):
                return visitor.visitSignal_list(self)
            else:
                return visitor.visitChildren(self)




    def signal_list(self):

        localctx = vhdlParser.Signal_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 422, self.RULE_signal_list)
        self._la = 0 # Token type
        try:
            self.state = 2192
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2182
                self.name()
                self.state = 2187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 2183
                    self.match(vhdlParser.COMMA)
                    self.state = 2184
                    self.name()
                    self.state = 2189
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2190
                self.match(vhdlParser.OTHERS)
                pass
            elif token in [vhdlParser.ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2191
                self.match(vhdlParser.ALL)
                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 SignatureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACKET(self):
            return self.getToken(vhdlParser.LBRACKET, 0)

        def RBRACKET(self):
            return self.getToken(vhdlParser.RBRACKET, 0)

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def RETURN(self):
            return self.getToken(vhdlParser.RETURN, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_signature

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignature" ):
                listener.enterSignature(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignature" ):
                listener.exitSignature(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignature" ):
                return visitor.visitSignature(self)
            else:
                return visitor.visitChildren(self)




    def signature(self):

        localctx = vhdlParser.SignatureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 424, self.RULE_signature)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2194
            self.match(vhdlParser.LBRACKET)
            self.state = 2203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 118)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 118)) | (1 << (vhdlParser.STRING_LITERAL - 118)))) != 0):
                self.state = 2195
                self.name()
                self.state = 2200
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 2196
                    self.match(vhdlParser.COMMA)
                    self.state = 2197
                    self.name()
                    self.state = 2202
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 2207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.RETURN:
                self.state = 2205
                self.match(vhdlParser.RETURN)
                self.state = 2206
                self.name()


            self.state = 2209
            self.match(vhdlParser.RBRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.TermContext)
            else:
                return self.getTypedRuleContext(vhdlParser.TermContext,i)


        def adding_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Adding_operatorContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Adding_operatorContext,i)


        def PLUS(self):
            return self.getToken(vhdlParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(vhdlParser.MINUS, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_simple_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimple_expression" ):
                listener.enterSimple_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimple_expression" ):
                listener.exitSimple_expression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimple_expression" ):
                return visitor.visitSimple_expression(self)
            else:
                return visitor.visitChildren(self)




    def simple_expression(self):

        localctx = vhdlParser.Simple_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 426, self.RULE_simple_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2212
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.PLUS or _la==vhdlParser.MINUS:
                self.state = 2211
                _la = self._input.LA(1)
                if not(_la==vhdlParser.PLUS or _la==vhdlParser.MINUS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2214
            self.term()
            self.state = 2220
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2215
                    self.adding_operator()
                    self.state = 2216
                    self.term() 
                self.state = 2222
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_simultaneous_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simple_expressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,i)


        def ASSIGN(self):
            return self.getToken(vhdlParser.ASSIGN, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def tolerance_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Tolerance_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simple_simultaneous_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimple_simultaneous_statement" ):
                listener.enterSimple_simultaneous_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimple_simultaneous_statement" ):
                listener.exitSimple_simultaneous_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimple_simultaneous_statement" ):
                return visitor.visitSimple_simultaneous_statement(self)
            else:
                return visitor.visitChildren(self)




    def simple_simultaneous_statement(self):

        localctx = vhdlParser.Simple_simultaneous_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 428, self.RULE_simple_simultaneous_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2224
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,243,self._ctx)
            if la_ == 1:
                self.state = 2223
                self.label_colon()


            self.state = 2226
            self.simple_expression()
            self.state = 2227
            self.match(vhdlParser.ASSIGN)
            self.state = 2228
            self.simple_expression()
            self.state = 2230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.TOLERANCE:
                self.state = 2229
                self.tolerance_aspect()


            self.state = 2232
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_alternativeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHEN(self):
            return self.getToken(vhdlParser.WHEN, 0)

        def choices(self):
            return self.getTypedRuleContext(vhdlParser.ChoicesContext,0)


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def simultaneous_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Simultaneous_statement_partContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_alternative

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_alternative" ):
                listener.enterSimultaneous_alternative(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_alternative" ):
                listener.exitSimultaneous_alternative(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_alternative" ):
                return visitor.visitSimultaneous_alternative(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_alternative(self):

        localctx = vhdlParser.Simultaneous_alternativeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 430, self.RULE_simultaneous_alternative)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2234
            self.match(vhdlParser.WHEN)
            self.state = 2235
            self.choices()
            self.state = 2236
            self.match(vhdlParser.ARROW)
            self.state = 2237
            self.simultaneous_statement_part()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_case_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CASE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.CASE)
            else:
                return self.getToken(vhdlParser.CASE, i)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def USE(self):
            return self.getToken(vhdlParser.USE, 0)

        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def simultaneous_alternative(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simultaneous_alternativeContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simultaneous_alternativeContext,i)


        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_case_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_case_statement" ):
                listener.enterSimultaneous_case_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_case_statement" ):
                listener.exitSimultaneous_case_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_case_statement" ):
                return visitor.visitSimultaneous_case_statement(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_case_statement(self):

        localctx = vhdlParser.Simultaneous_case_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 432, self.RULE_simultaneous_case_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2240
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2239
                self.label_colon()


            self.state = 2242
            self.match(vhdlParser.CASE)
            self.state = 2243
            self.expression()
            self.state = 2244
            self.match(vhdlParser.USE)
            self.state = 2246 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2245
                self.simultaneous_alternative()
                self.state = 2248 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.WHEN):
                    break

            self.state = 2250
            self.match(vhdlParser.END)
            self.state = 2251
            self.match(vhdlParser.CASE)
            self.state = 2253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2252
                self.identifier()


            self.state = 2255
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_if_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IF(self):
            return self.getToken(vhdlParser.IF, 0)

        def condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ConditionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ConditionContext,i)


        def USE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.USE)
            else:
                return self.getToken(vhdlParser.USE, i)

        def simultaneous_statement_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simultaneous_statement_partContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simultaneous_statement_partContext,i)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def ELSIF(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.ELSIF)
            else:
                return self.getToken(vhdlParser.ELSIF, i)

        def ELSE(self):
            return self.getToken(vhdlParser.ELSE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_if_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_if_statement" ):
                listener.enterSimultaneous_if_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_if_statement" ):
                listener.exitSimultaneous_if_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_if_statement" ):
                return visitor.visitSimultaneous_if_statement(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_if_statement(self):

        localctx = vhdlParser.Simultaneous_if_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 434, self.RULE_simultaneous_if_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2257
                self.label_colon()


            self.state = 2260
            self.match(vhdlParser.IF)
            self.state = 2261
            self.condition()
            self.state = 2262
            self.match(vhdlParser.USE)
            self.state = 2263
            self.simultaneous_statement_part()
            self.state = 2271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.ELSIF:
                self.state = 2264
                self.match(vhdlParser.ELSIF)
                self.state = 2265
                self.condition()
                self.state = 2266
                self.match(vhdlParser.USE)
                self.state = 2267
                self.simultaneous_statement_part()
                self.state = 2273
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ELSE:
                self.state = 2274
                self.match(vhdlParser.ELSE)
                self.state = 2275
                self.simultaneous_statement_part()


            self.state = 2278
            self.match(vhdlParser.END)
            self.state = 2279
            self.match(vhdlParser.USE)
            self.state = 2281
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2280
                self.identifier()


            self.state = 2283
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_procedural_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROCEDURAL(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.PROCEDURAL)
            else:
                return self.getToken(vhdlParser.PROCEDURAL, i)

        def procedural_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Procedural_declarative_partContext,0)


        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def procedural_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Procedural_statement_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_procedural_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_procedural_statement" ):
                listener.enterSimultaneous_procedural_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_procedural_statement" ):
                listener.exitSimultaneous_procedural_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_procedural_statement" ):
                return visitor.visitSimultaneous_procedural_statement(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_procedural_statement(self):

        localctx = vhdlParser.Simultaneous_procedural_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 436, self.RULE_simultaneous_procedural_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2285
                self.label_colon()


            self.state = 2288
            self.match(vhdlParser.PROCEDURAL)
            self.state = 2290
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS:
                self.state = 2289
                self.match(vhdlParser.IS)


            self.state = 2292
            self.procedural_declarative_part()
            self.state = 2293
            self.match(vhdlParser.BEGIN)
            self.state = 2294
            self.procedural_statement_part()
            self.state = 2295
            self.match(vhdlParser.END)
            self.state = 2296
            self.match(vhdlParser.PROCEDURAL)
            self.state = 2298
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2297
                self.identifier()


            self.state = 2300
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_simultaneous_statement(self):
            return self.getTypedRuleContext(vhdlParser.Simple_simultaneous_statementContext,0)


        def simultaneous_if_statement(self):
            return self.getTypedRuleContext(vhdlParser.Simultaneous_if_statementContext,0)


        def simultaneous_case_statement(self):
            return self.getTypedRuleContext(vhdlParser.Simultaneous_case_statementContext,0)


        def simultaneous_procedural_statement(self):
            return self.getTypedRuleContext(vhdlParser.Simultaneous_procedural_statementContext,0)


        def NULL_(self):
            return self.getToken(vhdlParser.NULL_, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_statement" ):
                listener.enterSimultaneous_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_statement" ):
                listener.exitSimultaneous_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_statement" ):
                return visitor.visitSimultaneous_statement(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_statement(self):

        localctx = vhdlParser.Simultaneous_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 438, self.RULE_simultaneous_statement)
        self._la = 0 # Token type
        try:
            self.state = 2311
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2302
                self.simple_simultaneous_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2303
                self.simultaneous_if_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2304
                self.simultaneous_case_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2305
                self.simultaneous_procedural_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2307
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                    self.state = 2306
                    self.label_colon()


                self.state = 2309
                self.match(vhdlParser.NULL_)
                self.state = 2310
                self.match(vhdlParser.SEMI)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simultaneous_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simultaneous_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simultaneous_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simultaneous_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_simultaneous_statement_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimultaneous_statement_part" ):
                listener.enterSimultaneous_statement_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimultaneous_statement_part" ):
                listener.exitSimultaneous_statement_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimultaneous_statement_part" ):
                return visitor.visitSimultaneous_statement_part(self)
            else:
                return visitor.visitChildren(self)




    def simultaneous_statement_part(self):

        localctx = vhdlParser.Simultaneous_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 440, self.RULE_simultaneous_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2316
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ABS) | (1 << vhdlParser.CASE) | (1 << vhdlParser.IF) | (1 << vhdlParser.NEW) | (1 << vhdlParser.NOT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (vhdlParser.PROCEDURAL - 69)) | (1 << (vhdlParser.BASE_LITERAL - 69)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 69)) | (1 << (vhdlParser.REAL_LITERAL - 69)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 69)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 69)) | (1 << (vhdlParser.CHARACTER_LITERAL - 69)) | (1 << (vhdlParser.STRING_LITERAL - 69)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (vhdlParser.LPAREN - 141)) | (1 << (vhdlParser.PLUS - 141)) | (1 << (vhdlParser.MINUS - 141)) | (1 << (vhdlParser.INTEGER - 141)))) != 0):
                self.state = 2313
                self.simultaneous_statement()
                self.state = 2318
                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 Source_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SPECTRUM(self):
            return self.getToken(vhdlParser.SPECTRUM, 0)

        def simple_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Simple_expressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,i)


        def COMMA(self):
            return self.getToken(vhdlParser.COMMA, 0)

        def NOISE(self):
            return self.getToken(vhdlParser.NOISE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_source_aspect

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSource_aspect" ):
                listener.enterSource_aspect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSource_aspect" ):
                listener.exitSource_aspect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSource_aspect" ):
                return visitor.visitSource_aspect(self)
            else:
                return visitor.visitChildren(self)




    def source_aspect(self):

        localctx = vhdlParser.Source_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 442, self.RULE_source_aspect)
        try:
            self.state = 2326
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.SPECTRUM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2319
                self.match(vhdlParser.SPECTRUM)
                self.state = 2320
                self.simple_expression()
                self.state = 2321
                self.match(vhdlParser.COMMA)
                self.state = 2322
                self.simple_expression()
                pass
            elif token in [vhdlParser.NOISE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2324
                self.match(vhdlParser.NOISE)
                self.state = 2325
                self.simple_expression()
                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 Source_quantity_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def QUANTITY(self):
            return self.getToken(vhdlParser.QUANTITY, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def source_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Source_aspectContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_source_quantity_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSource_quantity_declaration" ):
                listener.enterSource_quantity_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSource_quantity_declaration" ):
                listener.exitSource_quantity_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSource_quantity_declaration" ):
                return visitor.visitSource_quantity_declaration(self)
            else:
                return visitor.visitChildren(self)




    def source_quantity_declaration(self):

        localctx = vhdlParser.Source_quantity_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 444, self.RULE_source_quantity_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2328
            self.match(vhdlParser.QUANTITY)
            self.state = 2329
            self.identifier_list()
            self.state = 2330
            self.match(vhdlParser.COLON)
            self.state = 2331
            self.subtype_indication()
            self.state = 2332
            self.source_aspect()
            self.state = 2333
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Step_limit_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LIMIT(self):
            return self.getToken(vhdlParser.LIMIT, 0)

        def quantity_specification(self):
            return self.getTypedRuleContext(vhdlParser.Quantity_specificationContext,0)


        def WITH(self):
            return self.getToken(vhdlParser.WITH, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_step_limit_specification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStep_limit_specification" ):
                listener.enterStep_limit_specification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStep_limit_specification" ):
                listener.exitStep_limit_specification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStep_limit_specification" ):
                return visitor.visitStep_limit_specification(self)
            else:
                return visitor.visitChildren(self)




    def step_limit_specification(self):

        localctx = vhdlParser.Step_limit_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 446, self.RULE_step_limit_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2335
            self.match(vhdlParser.LIMIT)
            self.state = 2336
            self.quantity_specification()
            self.state = 2337
            self.match(vhdlParser.WITH)
            self.state = 2338
            self.expression()
            self.state = 2339
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subnature_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SUBNATURE(self):
            return self.getToken(vhdlParser.SUBNATURE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_subnature_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubnature_declaration" ):
                listener.enterSubnature_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubnature_declaration" ):
                listener.exitSubnature_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubnature_declaration" ):
                return visitor.visitSubnature_declaration(self)
            else:
                return visitor.visitChildren(self)




    def subnature_declaration(self):

        localctx = vhdlParser.Subnature_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 448, self.RULE_subnature_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2341
            self.match(vhdlParser.SUBNATURE)
            self.state = 2342
            self.identifier()
            self.state = 2343
            self.match(vhdlParser.IS)
            self.state = 2344
            self.subnature_indication()
            self.state = 2345
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subnature_indicationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(vhdlParser.NameContext,0)


        def index_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Index_constraintContext,0)


        def TOLERANCE(self):
            return self.getToken(vhdlParser.TOLERANCE, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ExpressionContext,i)


        def ACROSS(self):
            return self.getToken(vhdlParser.ACROSS, 0)

        def THROUGH(self):
            return self.getToken(vhdlParser.THROUGH, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_subnature_indication

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubnature_indication" ):
                listener.enterSubnature_indication(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubnature_indication" ):
                listener.exitSubnature_indication(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubnature_indication" ):
                return visitor.visitSubnature_indication(self)
            else:
                return visitor.visitChildren(self)




    def subnature_indication(self):

        localctx = vhdlParser.Subnature_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 450, self.RULE_subnature_indication)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2347
            self.name()
            self.state = 2349
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 2348
                self.index_constraint()


            self.state = 2357
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.TOLERANCE:
                self.state = 2351
                self.match(vhdlParser.TOLERANCE)
                self.state = 2352
                self.expression()
                self.state = 2353
                self.match(vhdlParser.ACROSS)
                self.state = 2354
                self.expression()
                self.state = 2355
                self.match(vhdlParser.THROUGH)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subprogram_specification(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_specificationContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def subprogram_declarative_part(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarative_partContext,0)


        def BEGIN(self):
            return self.getToken(vhdlParser.BEGIN, 0)

        def subprogram_statement_part(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_statement_partContext,0)


        def END(self):
            return self.getToken(vhdlParser.END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def subprogram_kind(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_kindContext,0)


        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_body" ):
                listener.enterSubprogram_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_body" ):
                listener.exitSubprogram_body(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_body" ):
                return visitor.visitSubprogram_body(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_body(self):

        localctx = vhdlParser.Subprogram_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 452, self.RULE_subprogram_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2359
            self.subprogram_specification()
            self.state = 2360
            self.match(vhdlParser.IS)
            self.state = 2361
            self.subprogram_declarative_part()
            self.state = 2362
            self.match(vhdlParser.BEGIN)
            self.state = 2363
            self.subprogram_statement_part()
            self.state = 2364
            self.match(vhdlParser.END)
            self.state = 2366
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FUNCTION or _la==vhdlParser.PROCEDURE:
                self.state = 2365
                self.subprogram_kind()


            self.state = 2369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 118)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 118)) | (1 << (vhdlParser.STRING_LITERAL - 118)))) != 0):
                self.state = 2368
                self.designator()


            self.state = 2371
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subprogram_specification(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_specificationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_declaration" ):
                listener.enterSubprogram_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_declaration" ):
                listener.exitSubprogram_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_declaration" ):
                return visitor.visitSubprogram_declaration(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_declaration(self):

        localctx = vhdlParser.Subprogram_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 454, self.RULE_subprogram_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2373
            self.subprogram_specification()
            self.state = 2374
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_declarative_itemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_declarationContext,0)


        def subprogram_body(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_bodyContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Type_declarationContext,0)


        def subtype_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_declarationContext,0)


        def constant_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Constant_declarationContext,0)


        def variable_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Variable_declarationContext,0)


        def file_declaration(self):
            return self.getTypedRuleContext(vhdlParser.File_declarationContext,0)


        def alias_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Alias_declarationContext,0)


        def attribute_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_declarationContext,0)


        def attribute_specification(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_specificationContext,0)


        def use_clause(self):
            return self.getTypedRuleContext(vhdlParser.Use_clauseContext,0)


        def group_template_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_template_declarationContext,0)


        def group_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Group_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_declarative_item

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_declarative_item" ):
                listener.enterSubprogram_declarative_item(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_declarative_item" ):
                listener.exitSubprogram_declarative_item(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_declarative_item" ):
                return visitor.visitSubprogram_declarative_item(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_declarative_item(self):

        localctx = vhdlParser.Subprogram_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 456, self.RULE_subprogram_declarative_item)
        try:
            self.state = 2389
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2376
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2377
                self.subprogram_body()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2378
                self.type_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2379
                self.subtype_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2380
                self.constant_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2381
                self.variable_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2382
                self.file_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2383
                self.alias_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2384
                self.attribute_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2385
                self.attribute_specification()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2386
                self.use_clause()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2387
                self.group_template_declaration()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2388
                self.group_declaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_declarative_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subprogram_declarative_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Subprogram_declarative_itemContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Subprogram_declarative_itemContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_declarative_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_declarative_part" ):
                listener.enterSubprogram_declarative_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_declarative_part" ):
                listener.exitSubprogram_declarative_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_declarative_part" ):
                return visitor.visitSubprogram_declarative_part(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_declarative_part(self):

        localctx = vhdlParser.Subprogram_declarative_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 458, self.RULE_subprogram_declarative_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ALIAS) | (1 << vhdlParser.ATTRIBUTE) | (1 << vhdlParser.CONSTANT) | (1 << vhdlParser.FILE) | (1 << vhdlParser.FUNCTION) | (1 << vhdlParser.GROUP) | (1 << vhdlParser.IMPURE))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.PROCEDURE - 68)) | (1 << (vhdlParser.PURE - 68)) | (1 << (vhdlParser.SHARED - 68)) | (1 << (vhdlParser.SUBTYPE - 68)) | (1 << (vhdlParser.TYPE - 68)) | (1 << (vhdlParser.USE - 68)) | (1 << (vhdlParser.VARIABLE - 68)))) != 0):
                self.state = 2391
                self.subprogram_declarative_item()
                self.state = 2396
                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 Subprogram_kindContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROCEDURE(self):
            return self.getToken(vhdlParser.PROCEDURE, 0)

        def FUNCTION(self):
            return self.getToken(vhdlParser.FUNCTION, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_kind

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_kind" ):
                listener.enterSubprogram_kind(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_kind" ):
                listener.exitSubprogram_kind(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_kind" ):
                return visitor.visitSubprogram_kind(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_kind(self):

        localctx = vhdlParser.Subprogram_kindContext(self, self._ctx, self.state)
        self.enterRule(localctx, 460, self.RULE_subprogram_kind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2397
            _la = self._input.LA(1)
            if not(_la==vhdlParser.FUNCTION or _la==vhdlParser.PROCEDURE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def procedure_specification(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_specificationContext,0)


        def function_specification(self):
            return self.getTypedRuleContext(vhdlParser.Function_specificationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_specification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_specification" ):
                listener.enterSubprogram_specification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_specification" ):
                listener.exitSubprogram_specification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_specification" ):
                return visitor.visitSubprogram_specification(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_specification(self):

        localctx = vhdlParser.Subprogram_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 462, self.RULE_subprogram_specification)
        try:
            self.state = 2401
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.PROCEDURE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2399
                self.procedure_specification()
                pass
            elif token in [vhdlParser.FUNCTION, vhdlParser.IMPURE, vhdlParser.PURE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2400
                self.function_specification()
                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 Procedure_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROCEDURE(self):
            return self.getToken(vhdlParser.PROCEDURE, 0)

        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(vhdlParser.Formal_parameter_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_procedure_specification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProcedure_specification" ):
                listener.enterProcedure_specification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProcedure_specification" ):
                listener.exitProcedure_specification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitProcedure_specification" ):
                return visitor.visitProcedure_specification(self)
            else:
                return visitor.visitChildren(self)




    def procedure_specification(self):

        localctx = vhdlParser.Procedure_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 464, self.RULE_procedure_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2403
            self.match(vhdlParser.PROCEDURE)
            self.state = 2404
            self.designator()
            self.state = 2409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 2405
                self.match(vhdlParser.LPAREN)
                self.state = 2406
                self.formal_parameter_list()
                self.state = 2407
                self.match(vhdlParser.RPAREN)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Function_specificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FUNCTION(self):
            return self.getToken(vhdlParser.FUNCTION, 0)

        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


        def RETURN(self):
            return self.getToken(vhdlParser.RETURN, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(vhdlParser.Formal_parameter_listContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def PURE(self):
            return self.getToken(vhdlParser.PURE, 0)

        def IMPURE(self):
            return self.getToken(vhdlParser.IMPURE, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_function_specification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunction_specification" ):
                listener.enterFunction_specification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunction_specification" ):
                listener.exitFunction_specification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunction_specification" ):
                return visitor.visitFunction_specification(self)
            else:
                return visitor.visitChildren(self)




    def function_specification(self):

        localctx = vhdlParser.Function_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 466, self.RULE_function_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IMPURE or _la==vhdlParser.PURE:
                self.state = 2411
                _la = self._input.LA(1)
                if not(_la==vhdlParser.IMPURE or _la==vhdlParser.PURE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2414
            self.match(vhdlParser.FUNCTION)
            self.state = 2415
            self.designator()
            self.state = 2420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 2416
                self.match(vhdlParser.LPAREN)
                self.state = 2417
                self.formal_parameter_list()
                self.state = 2418
                self.match(vhdlParser.RPAREN)


            self.state = 2422
            self.match(vhdlParser.RETURN)
            self.state = 2423
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_statement_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sequential_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Sequential_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Sequential_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_statement_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubprogram_statement_part" ):
                listener.enterSubprogram_statement_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubprogram_statement_part" ):
                listener.exitSubprogram_statement_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubprogram_statement_part" ):
                return visitor.visitSubprogram_statement_part(self)
            else:
                return visitor.visitChildren(self)




    def subprogram_statement_part(self):

        localctx = vhdlParser.Subprogram_statement_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 468, self.RULE_subprogram_statement_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.ASSERT) | (1 << vhdlParser.BREAK) | (1 << vhdlParser.CASE) | (1 << vhdlParser.EXIT) | (1 << vhdlParser.FOR) | (1 << vhdlParser.IF) | (1 << vhdlParser.LOOP) | (1 << vhdlParser.NEXT) | (1 << vhdlParser.NULL_))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (vhdlParser.REPORT - 79)) | (1 << (vhdlParser.RETURN - 79)) | (1 << (vhdlParser.WAIT - 79)) | (1 << (vhdlParser.WHILE - 79)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 79)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 79)) | (1 << (vhdlParser.STRING_LITERAL - 79)) | (1 << (vhdlParser.LPAREN - 79)))) != 0):
                self.state = 2425
                self.sequential_statement()
                self.state = 2430
                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 Subtype_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SUBTYPE(self):
            return self.getToken(vhdlParser.SUBTYPE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_subtype_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubtype_declaration" ):
                listener.enterSubtype_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubtype_declaration" ):
                listener.exitSubtype_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubtype_declaration" ):
                return visitor.visitSubtype_declaration(self)
            else:
                return visitor.visitChildren(self)




    def subtype_declaration(self):

        localctx = vhdlParser.Subtype_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 470, self.RULE_subtype_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2431
            self.match(vhdlParser.SUBTYPE)
            self.state = 2432
            self.identifier()
            self.state = 2433
            self.match(vhdlParser.IS)
            self.state = 2434
            self.subtype_indication()
            self.state = 2435
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subtype_indicationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def selected_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Selected_nameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Selected_nameContext,i)


        def constraint(self):
            return self.getTypedRuleContext(vhdlParser.ConstraintContext,0)


        def tolerance_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Tolerance_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_subtype_indication

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubtype_indication" ):
                listener.enterSubtype_indication(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubtype_indication" ):
                listener.exitSubtype_indication(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubtype_indication" ):
                return visitor.visitSubtype_indication(self)
            else:
                return visitor.visitChildren(self)




    def subtype_indication(self):

        localctx = vhdlParser.Subtype_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 472, self.RULE_subtype_indication)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2437
            self.selected_name()
            self.state = 2439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2438
                self.selected_name()


            self.state = 2442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.RANGE or _la==vhdlParser.LPAREN:
                self.state = 2441
                self.constraint()


            self.state = 2445
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,272,self._ctx)
            if la_ == 1:
                self.state = 2444
                self.tolerance_aspect()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SuffixContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def CHARACTER_LITERAL(self):
            return self.getToken(vhdlParser.CHARACTER_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(vhdlParser.STRING_LITERAL, 0)

        def ALL(self):
            return self.getToken(vhdlParser.ALL, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_suffix

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSuffix" ):
                listener.enterSuffix(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSuffix" ):
                listener.exitSuffix(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSuffix" ):
                return visitor.visitSuffix(self)
            else:
                return visitor.visitChildren(self)




    def suffix(self):

        localctx = vhdlParser.SuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 474, self.RULE_suffix)
        try:
            self.state = 2451
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2447
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2448
                self.match(vhdlParser.CHARACTER_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2449
                self.match(vhdlParser.STRING_LITERAL)
                pass
            elif token in [vhdlParser.ALL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2450
                self.match(vhdlParser.ALL)
                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 TargetContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(vhdlParser.NameContext,0)


        def aggregate(self):
            return self.getTypedRuleContext(vhdlParser.AggregateContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_target

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTarget" ):
                listener.enterTarget(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTarget" ):
                listener.exitTarget(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTarget" ):
                return visitor.visitTarget(self)
            else:
                return visitor.visitChildren(self)




    def target(self):

        localctx = vhdlParser.TargetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 476, self.RULE_target)
        try:
            self.state = 2455
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2453
                self.name()
                pass
            elif token in [vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2454
                self.aggregate()
                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 TermContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.FactorContext)
            else:
                return self.getTypedRuleContext(vhdlParser.FactorContext,i)


        def multiplying_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Multiplying_operatorContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Multiplying_operatorContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_term

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTerm" ):
                listener.enterTerm(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTerm" ):
                listener.exitTerm(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTerm" ):
                return visitor.visitTerm(self)
            else:
                return visitor.visitChildren(self)




    def term(self):

        localctx = vhdlParser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 478, self.RULE_term)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2457
            self.factor()
            self.state = 2463
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,275,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2458
                    self.multiplying_operator()
                    self.state = 2459
                    self.factor() 
                self.state = 2465
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,275,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Terminal_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.NameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.NameContext,i)


        def TO(self):
            return self.getToken(vhdlParser.TO, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_terminal_aspect

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTerminal_aspect" ):
                listener.enterTerminal_aspect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTerminal_aspect" ):
                listener.exitTerminal_aspect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTerminal_aspect" ):
                return visitor.visitTerminal_aspect(self)
            else:
                return visitor.visitChildren(self)




    def terminal_aspect(self):

        localctx = vhdlParser.Terminal_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 480, self.RULE_terminal_aspect)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2466
            self.name()
            self.state = 2469
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.TO:
                self.state = 2467
                self.match(vhdlParser.TO)
                self.state = 2468
                self.name()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Terminal_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TERMINAL(self):
            return self.getToken(vhdlParser.TERMINAL, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_terminal_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTerminal_declaration" ):
                listener.enterTerminal_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTerminal_declaration" ):
                listener.exitTerminal_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTerminal_declaration" ):
                return visitor.visitTerminal_declaration(self)
            else:
                return visitor.visitChildren(self)




    def terminal_declaration(self):

        localctx = vhdlParser.Terminal_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 482, self.RULE_terminal_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2471
            self.match(vhdlParser.TERMINAL)
            self.state = 2472
            self.identifier_list()
            self.state = 2473
            self.match(vhdlParser.COLON)
            self.state = 2474
            self.subnature_indication()
            self.state = 2475
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Through_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def THROUGH(self):
            return self.getToken(vhdlParser.THROUGH, 0)

        def tolerance_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Tolerance_aspectContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_through_aspect

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterThrough_aspect" ):
                listener.enterThrough_aspect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitThrough_aspect" ):
                listener.exitThrough_aspect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrough_aspect" ):
                return visitor.visitThrough_aspect(self)
            else:
                return visitor.visitChildren(self)




    def through_aspect(self):

        localctx = vhdlParser.Through_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 484, self.RULE_through_aspect)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2477
            self.identifier_list()
            self.state = 2479
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.TOLERANCE:
                self.state = 2478
                self.tolerance_aspect()


            self.state = 2483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 2481
                self.match(vhdlParser.VARASGN)
                self.state = 2482
                self.expression()


            self.state = 2485
            self.match(vhdlParser.THROUGH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Timeout_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FOR(self):
            return self.getToken(vhdlParser.FOR, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_timeout_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimeout_clause" ):
                listener.enterTimeout_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimeout_clause" ):
                listener.exitTimeout_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTimeout_clause" ):
                return visitor.visitTimeout_clause(self)
            else:
                return visitor.visitChildren(self)




    def timeout_clause(self):

        localctx = vhdlParser.Timeout_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 486, self.RULE_timeout_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2487
            self.match(vhdlParser.FOR)
            self.state = 2488
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tolerance_aspectContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TOLERANCE(self):
            return self.getToken(vhdlParser.TOLERANCE, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_tolerance_aspect

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTolerance_aspect" ):
                listener.enterTolerance_aspect(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTolerance_aspect" ):
                listener.exitTolerance_aspect(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTolerance_aspect" ):
                return visitor.visitTolerance_aspect(self)
            else:
                return visitor.visitChildren(self)




    def tolerance_aspect(self):

        localctx = vhdlParser.Tolerance_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 488, self.RULE_tolerance_aspect)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2490
            self.match(vhdlParser.TOLERANCE)
            self.state = 2491
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TYPE(self):
            return self.getToken(vhdlParser.TYPE, 0)

        def identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def IS(self):
            return self.getToken(vhdlParser.IS, 0)

        def type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Type_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_type_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_declaration" ):
                listener.enterType_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_declaration" ):
                listener.exitType_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitType_declaration" ):
                return visitor.visitType_declaration(self)
            else:
                return visitor.visitChildren(self)




    def type_declaration(self):

        localctx = vhdlParser.Type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 490, self.RULE_type_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2493
            self.match(vhdlParser.TYPE)
            self.state = 2494
            self.identifier()
            self.state = 2497
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.IS:
                self.state = 2495
                self.match(vhdlParser.IS)
                self.state = 2496
                self.type_definition()


            self.state = 2499
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def scalar_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Scalar_type_definitionContext,0)


        def composite_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Composite_type_definitionContext,0)


        def access_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Access_type_definitionContext,0)


        def file_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.File_type_definitionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_type_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_definition" ):
                listener.enterType_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_definition" ):
                listener.exitType_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitType_definition" ):
                return visitor.visitType_definition(self)
            else:
                return visitor.visitChildren(self)




    def type_definition(self):

        localctx = vhdlParser.Type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 492, self.RULE_type_definition)
        try:
            self.state = 2505
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.RANGE, vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2501
                self.scalar_type_definition()
                pass
            elif token in [vhdlParser.ARRAY, vhdlParser.RECORD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2502
                self.composite_type_definition()
                pass
            elif token in [vhdlParser.ACCESS]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2503
                self.access_type_definition()
                pass
            elif token in [vhdlParser.FILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2504
                self.file_type_definition()
                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 Unconstrained_array_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ARRAY(self):
            return self.getToken(vhdlParser.ARRAY, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def index_subtype_definition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Index_subtype_definitionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Index_subtype_definitionContext,i)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_unconstrained_array_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnconstrained_array_definition" ):
                listener.enterUnconstrained_array_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnconstrained_array_definition" ):
                listener.exitUnconstrained_array_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnconstrained_array_definition" ):
                return visitor.visitUnconstrained_array_definition(self)
            else:
                return visitor.visitChildren(self)




    def unconstrained_array_definition(self):

        localctx = vhdlParser.Unconstrained_array_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 494, self.RULE_unconstrained_array_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2507
            self.match(vhdlParser.ARRAY)
            self.state = 2508
            self.match(vhdlParser.LPAREN)
            self.state = 2509
            self.index_subtype_definition()
            self.state = 2514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2510
                self.match(vhdlParser.COMMA)
                self.state = 2511
                self.index_subtype_definition()
                self.state = 2516
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2517
            self.match(vhdlParser.RPAREN)
            self.state = 2518
            self.match(vhdlParser.OF)
            self.state = 2519
            self.subtype_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Unconstrained_nature_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ARRAY(self):
            return self.getToken(vhdlParser.ARRAY, 0)

        def LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 0)

        def index_subtype_definition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Index_subtype_definitionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Index_subtype_definitionContext,i)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 0)

        def OF(self):
            return self.getToken(vhdlParser.OF, 0)

        def subnature_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subnature_indicationContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_unconstrained_nature_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnconstrained_nature_definition" ):
                listener.enterUnconstrained_nature_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnconstrained_nature_definition" ):
                listener.exitUnconstrained_nature_definition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnconstrained_nature_definition" ):
                return visitor.visitUnconstrained_nature_definition(self)
            else:
                return visitor.visitChildren(self)




    def unconstrained_nature_definition(self):

        localctx = vhdlParser.Unconstrained_nature_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 496, self.RULE_unconstrained_nature_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2521
            self.match(vhdlParser.ARRAY)
            self.state = 2522
            self.match(vhdlParser.LPAREN)
            self.state = 2523
            self.index_subtype_definition()
            self.state = 2528
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2524
                self.match(vhdlParser.COMMA)
                self.state = 2525
                self.index_subtype_definition()
                self.state = 2530
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2531
            self.match(vhdlParser.RPAREN)
            self.state = 2532
            self.match(vhdlParser.OF)
            self.state = 2533
            self.subnature_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Use_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def USE(self):
            return self.getToken(vhdlParser.USE, 0)

        def selected_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Selected_nameContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Selected_nameContext,i)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_use_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUse_clause" ):
                listener.enterUse_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUse_clause" ):
                listener.exitUse_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUse_clause" ):
                return visitor.visitUse_clause(self)
            else:
                return visitor.visitChildren(self)




    def use_clause(self):

        localctx = vhdlParser.Use_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 498, self.RULE_use_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2535
            self.match(vhdlParser.USE)
            self.state = 2536
            self.selected_name()
            self.state = 2541
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2537
                self.match(vhdlParser.COMMA)
                self.state = 2538
                self.selected_name()
                self.state = 2543
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2544
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variable_assignment_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def target(self):
            return self.getTypedRuleContext(vhdlParser.TargetContext,0)


        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_variable_assignment_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariable_assignment_statement" ):
                listener.enterVariable_assignment_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariable_assignment_statement" ):
                listener.exitVariable_assignment_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariable_assignment_statement" ):
                return visitor.visitVariable_assignment_statement(self)
            else:
                return visitor.visitChildren(self)




    def variable_assignment_statement(self):

        localctx = vhdlParser.Variable_assignment_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 500, self.RULE_variable_assignment_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2547
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
            if la_ == 1:
                self.state = 2546
                self.label_colon()


            self.state = 2549
            self.target()
            self.state = 2550
            self.match(vhdlParser.VARASGN)
            self.state = 2551
            self.expression()
            self.state = 2552
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variable_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def VARIABLE(self):
            return self.getToken(vhdlParser.VARIABLE, 0)

        def identifier_list(self):
            return self.getTypedRuleContext(vhdlParser.Identifier_listContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_indicationContext,0)


        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def SHARED(self):
            return self.getToken(vhdlParser.SHARED, 0)

        def VARASGN(self):
            return self.getToken(vhdlParser.VARASGN, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_variable_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariable_declaration" ):
                listener.enterVariable_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariable_declaration" ):
                listener.exitVariable_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariable_declaration" ):
                return visitor.visitVariable_declaration(self)
            else:
                return visitor.visitChildren(self)




    def variable_declaration(self):

        localctx = vhdlParser.Variable_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 502, self.RULE_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.SHARED:
                self.state = 2554
                self.match(vhdlParser.SHARED)


            self.state = 2557
            self.match(vhdlParser.VARIABLE)
            self.state = 2558
            self.identifier_list()
            self.state = 2559
            self.match(vhdlParser.COLON)
            self.state = 2560
            self.subtype_indication()
            self.state = 2563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 2561
                self.match(vhdlParser.VARASGN)
                self.state = 2562
                self.expression()


            self.state = 2565
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Wait_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WAIT(self):
            return self.getToken(vhdlParser.WAIT, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label_colon(self):
            return self.getTypedRuleContext(vhdlParser.Label_colonContext,0)


        def sensitivity_clause(self):
            return self.getTypedRuleContext(vhdlParser.Sensitivity_clauseContext,0)


        def condition_clause(self):
            return self.getTypedRuleContext(vhdlParser.Condition_clauseContext,0)


        def timeout_clause(self):
            return self.getTypedRuleContext(vhdlParser.Timeout_clauseContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_wait_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWait_statement" ):
                listener.enterWait_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWait_statement" ):
                listener.exitWait_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWait_statement" ):
                return visitor.visitWait_statement(self)
            else:
                return visitor.visitChildren(self)




    def wait_statement(self):

        localctx = vhdlParser.Wait_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 504, self.RULE_wait_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2567
                self.label_colon()


            self.state = 2570
            self.match(vhdlParser.WAIT)
            self.state = 2572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.ON:
                self.state = 2571
                self.sensitivity_clause()


            self.state = 2575
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.UNTIL:
                self.state = 2574
                self.condition_clause()


            self.state = 2578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.FOR:
                self.state = 2577
                self.timeout_clause()


            self.state = 2580
            self.match(vhdlParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WaveformContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def waveform_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Waveform_elementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Waveform_elementContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COMMA)
            else:
                return self.getToken(vhdlParser.COMMA, i)

        def UNAFFECTED(self):
            return self.getToken(vhdlParser.UNAFFECTED, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_waveform

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWaveform" ):
                listener.enterWaveform(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWaveform" ):
                listener.exitWaveform(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWaveform" ):
                return visitor.visitWaveform(self)
            else:
                return visitor.visitChildren(self)




    def waveform(self):

        localctx = vhdlParser.WaveformContext(self, self._ctx, self.state)
        self.enterRule(localctx, 506, self.RULE_waveform)
        self._la = 0 # Token type
        try:
            self.state = 2591
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.ABS, vhdlParser.NEW, vhdlParser.NOT, vhdlParser.NULL_, vhdlParser.BASE_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.REAL_LITERAL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.PLUS, vhdlParser.MINUS, vhdlParser.INTEGER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2582
                self.waveform_element()
                self.state = 2587
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 2583
                    self.match(vhdlParser.COMMA)
                    self.state = 2584
                    self.waveform_element()
                    self.state = 2589
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.UNAFFECTED]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2590
                self.match(vhdlParser.UNAFFECTED)
                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 Waveform_elementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.ExpressionContext,i)


        def AFTER(self):
            return self.getToken(vhdlParser.AFTER, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_waveform_element

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWaveform_element" ):
                listener.enterWaveform_element(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWaveform_element" ):
                listener.exitWaveform_element(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWaveform_element" ):
                return visitor.visitWaveform_element(self)
            else:
                return visitor.visitChildren(self)




    def waveform_element(self):

        localctx = vhdlParser.Waveform_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 508, self.RULE_waveform_element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2593
            self.expression()
            self.state = 2596
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.AFTER:
                self.state = 2594
                self.match(vhdlParser.AFTER)
                self.state = 2595
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





