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


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


class vhdlParser ( Parser ):

    grammarFileName = "vhdlParser.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>", 
                     "'\n'", "'\r'", "' '", "'\"'", "'_'", "<INVALID>", 
                     "';'", "'('", "')'", "'['", "']'", "'''", "'<<'", "'>>'", 
                     "'@'", "'#'", "','", "'.'", "'?'", "':'", "'='", "'/='", 
                     "'<'", "'>'", "'>='", "'?='", "'?/='", "'?<'", "'?<='", 
                     "'?>'", "'?>='", "'+'", "'-'", "'&'", "'|'", "'\\'", 
                     "'*'", "'/'", "'**'", "'<='", "'`'", "'^'", "':='", 
                     "'<>'", "'=>'" ]

    symbolicNames = [ "<INVALID>", "KW_PROCESS", "KW_CONTEXT", "KW_POSTPONED", 
                      "KW_LINKAGE", "KW_COMPONENT", "KW_ABS", "KW_DEFAULT", 
                      "KW_THEN", "KW_BLOCK", "KW_REM", "KW_INERTIAL", "KW_NEXT", 
                      "KW_ENTITY", "KW_ON", "KW_GROUP", "KW_XNOR", "KW_FILE", 
                      "KW_PURE", "KW_GUARDED", "KW_GENERIC", "KW_RANGE", 
                      "KW_ELSE", "KW_USE", "KW_SHARED", "KW_MOD", "KW_LOOP", 
                      "KW_RECORD", "KW_SIGNAL", "KW_REJECT", "KW_BEGIN", 
                      "KW_SLA", "KW_DISCONNECT", "KW_OF", "KW_PROCEDURE", 
                      "KW_SRL", "KW_VUNIT", "KW_ATTRIBUTE", "KW_VARIABLE", 
                      "KW_PROPERTY", "KW_UNAFFECTED", "KW_XOR", "KW_REGISTER", 
                      "KW_SUBTYPE", "KW_TO", "KW_NEW", "KW_REPORT", "KW_CONSTANT", 
                      "KW_BUFFER", "KW_BODY", "KW_AFTER", "KW_TRANSPORT", 
                      "KW_FUNCTION", "KW_END", "KW_SELECT", "KW_OR", "KW_LIBRARY", 
                      "KW_ELSIF", "KW_SLL", "KW_MAP", "KW_SRA", "KW_PROTECTED", 
                      "KW_DOWNTO", "KW_LABEL", "KW_ALL", "KW_ALIAS", "KW_GENERATE", 
                      "KW_NOR", "KW_IN", "KW_RELEASE", "KW_EXIT", "KW_RETURN", 
                      "KW_WITH", "KW_UNTIL", "KW_AND", "KW_INOUT", "KW_WAIT", 
                      "KW_NAND", "KW_ARRAY", "KW_FORCE", "KW_WHILE", "KW_IMPURE", 
                      "KW_PACKAGE", "KW_UNITS", "KW_ASSERT", "KW_PARAMETER", 
                      "KW_SEVERITY", "KW_LITERAL", "KW_FOR", "KW_ROR", "KW_IF", 
                      "KW_OUT", "KW_ROL", "KW_IS", "KW_SEQUENCE", "KW_OTHERS", 
                      "KW_TYPE", "KW_CASE", "KW_NOT", "KW_CONFIGURATION", 
                      "KW_OPEN", "KW_ARCHITECTURE", "KW_BUS", "KW_ACCESS", 
                      "KW_WHEN", "KW_PORT", "KW_NULL", "BASIC_IDENTIFIER", 
                      "EXTENDED_IDENTIFIER", "DECIMAL_LITERAL", "INTEGER", 
                      "EXPONENT", "BASED_LITERAL", "CHARACTER_LITERAL", 
                      "STRING_LITERAL", "BIT_STRING_LITERAL", "COMMENT", 
                      "BLOCK_COMMENT", "TAB", "SPACE", "NEWLINE", "CR", 
                      "SPACE_CHARACTER", "DBLQUOTE", "UNDERSCORE", "DIGIT", 
                      "SEMI", "LPAREN", "RPAREN", "LSQUARE_BR", "RSQUARE_BR", 
                      "APOSTROPHE", "SHIFT_LEFT", "SHIFT_RIGHT", "AT", "HASHTAG", 
                      "COMMA", "DOT", "QUESTIONMARK", "COLON", "EQ", "NE", 
                      "LT", "GT", "GE", "EQ_MATCH", "NE_MATCH", "LT_MATCH", 
                      "LE_MATCH", "GT_MATCH", "GE_MATCH", "PLUS", "MINUS", 
                      "AMPERSAND", "BAR", "BACKSLASH", "MUL", "DIV", "DOUBLESTAR", 
                      "CONASGN", "GRAVE_ACCENT", "UP", "VARASGN", "BOX", 
                      "ARROW", "COND_OP" ]

    RULE_any_keyword = 0
    RULE_name_literal = 1
    RULE_name = 2
    RULE_name_slice_part = 3
    RULE_name_attribute_part = 4
    RULE_attribute_name = 5
    RULE_suffix = 6
    RULE_explicit_range = 7
    RULE_selected_name = 8
    RULE_entity_declaration = 9
    RULE_entity_declarative_item = 10
    RULE_entity_statement = 11
    RULE_architecture_body = 12
    RULE_block_declarative_item = 13
    RULE_configuration_declaration = 14
    RULE_configuration_declarative_item = 15
    RULE_block_configuration = 16
    RULE_block_specification = 17
    RULE_generate_specification = 18
    RULE_configuration_item = 19
    RULE_component_configuration = 20
    RULE_subprogram_declaration = 21
    RULE_subprogram_specification = 22
    RULE_procedure_specification = 23
    RULE_function_specification = 24
    RULE_subprogram_header = 25
    RULE_designator = 26
    RULE_operator_symbol = 27
    RULE_formal_parameter_list = 28
    RULE_subprogram_body = 29
    RULE_subprogram_kind = 30
    RULE_subprogram_instantiation_declaration = 31
    RULE_signature = 32
    RULE_package_declaration = 33
    RULE_package_declarative_item = 34
    RULE_package_body = 35
    RULE_package_instantiation_declaration = 36
    RULE_scalar_type_definition = 37
    RULE_range_constraint = 38
    RULE_range_ = 39
    RULE_direction = 40
    RULE_enumeration_type_definition = 41
    RULE_enumeration_literal = 42
    RULE_integer_type_definition = 43
    RULE_physical_type_definition = 44
    RULE_primary_unit_declaration = 45
    RULE_secondary_unit_declaration = 46
    RULE_floating_type_definition = 47
    RULE_composite_type_definition = 48
    RULE_array_type_definition = 49
    RULE_unbounded_array_definition = 50
    RULE_constrained_array_definition = 51
    RULE_index_subtype_definition = 52
    RULE_array_constraint = 53
    RULE_array_element_constraint = 54
    RULE_index_constraint = 55
    RULE_discrete_range = 56
    RULE_record_type_definition = 57
    RULE_element_declaration = 58
    RULE_identifier_list = 59
    RULE_element_subtype_definition = 60
    RULE_record_constraint = 61
    RULE_record_element_constraint = 62
    RULE_access_type_definition = 63
    RULE_incomplete_type_declaration = 64
    RULE_file_type_definition = 65
    RULE_protected_type_definition = 66
    RULE_protected_type_declaration = 67
    RULE_protected_type_declarative_item = 68
    RULE_protected_type_body = 69
    RULE_type_declaration = 70
    RULE_full_type_declaration = 71
    RULE_type_definition = 72
    RULE_subtype_declaration = 73
    RULE_subtype_indication = 74
    RULE_resolution_indication = 75
    RULE_element_resolution = 76
    RULE_array_element_resolution = 77
    RULE_record_resolution = 78
    RULE_record_element_resolution = 79
    RULE_type_mark = 80
    RULE_constraint = 81
    RULE_element_constraint = 82
    RULE_object_declaration = 83
    RULE_constant_declaration = 84
    RULE_signal_declaration = 85
    RULE_signal_kind = 86
    RULE_variable_declaration = 87
    RULE_file_declaration = 88
    RULE_file_open_information = 89
    RULE_file_logical_name = 90
    RULE_interface_declaration = 91
    RULE_interface_object_declaration = 92
    RULE_interface_constant_declaration = 93
    RULE_interface_signal_declaration = 94
    RULE_interface_variable_declaration = 95
    RULE_interface_file_declaration = 96
    RULE_signal_mode = 97
    RULE_interface_type_declaration = 98
    RULE_interface_incomplete_type_declaration = 99
    RULE_interface_subprogram_declaration = 100
    RULE_interface_subprogram_specification = 101
    RULE_interface_procedure_specification = 102
    RULE_interface_function_specification = 103
    RULE_interface_subprogram_default = 104
    RULE_interface_package_declaration = 105
    RULE_interface_package_generic_map_aspect = 106
    RULE_interface_list = 107
    RULE_interface_element = 108
    RULE_generic_clause = 109
    RULE_generic_list = 110
    RULE_port_clause = 111
    RULE_port_list = 112
    RULE_association_list = 113
    RULE_association_element = 114
    RULE_formal_part = 115
    RULE_actual_part = 116
    RULE_actual_designator = 117
    RULE_generic_map_aspect = 118
    RULE_port_map_aspect = 119
    RULE_alias_declaration = 120
    RULE_alias_designator = 121
    RULE_attribute_declaration = 122
    RULE_component_declaration = 123
    RULE_group_template_declaration = 124
    RULE_entity_class_entry_list = 125
    RULE_entity_class_entry = 126
    RULE_group_declaration = 127
    RULE_group_constituent_list = 128
    RULE_group_constituent = 129
    RULE_attribute_specification = 130
    RULE_entity_specification = 131
    RULE_entity_class = 132
    RULE_entity_name_list = 133
    RULE_entity_designator = 134
    RULE_entity_tag = 135
    RULE_configuration_specification = 136
    RULE_simple_configuration_specification = 137
    RULE_compound_configuration_specification = 138
    RULE_component_specification = 139
    RULE_instantiation_list = 140
    RULE_binding_indication = 141
    RULE_entity_aspect = 142
    RULE_verification_unit_binding_indication = 143
    RULE_verification_unit_list = 144
    RULE_disconnection_specification = 145
    RULE_guarded_signal_specification = 146
    RULE_signal_list = 147
    RULE_attribute_designator = 148
    RULE_external_name = 149
    RULE_external_pathname = 150
    RULE_package_pathname = 151
    RULE_absolute_pathname = 152
    RULE_relative_pathname = 153
    RULE_partial_pathname = 154
    RULE_pathname_element = 155
    RULE_expression = 156
    RULE_simple_expression = 157
    RULE_primary = 158
    RULE_logical_operator = 159
    RULE_relational_operator = 160
    RULE_shift_operator = 161
    RULE_adding_operator = 162
    RULE_sign = 163
    RULE_multiplying_operator = 164
    RULE_miscellaneous_operator = 165
    RULE_numeric_literal = 166
    RULE_physical_literal = 167
    RULE_aggregate = 168
    RULE_element_association = 169
    RULE_choices = 170
    RULE_choice = 171
    RULE_qualified_expression = 172
    RULE_allocator = 173
    RULE_sequence_of_statements = 174
    RULE_sequential_statement = 175
    RULE_wait_statement = 176
    RULE_sensitivity_clause = 177
    RULE_sensitivity_list = 178
    RULE_condition_clause = 179
    RULE_condition = 180
    RULE_timeout_clause = 181
    RULE_assertion_statement = 182
    RULE_assertion = 183
    RULE_report_statement = 184
    RULE_signal_assignment_statement = 185
    RULE_simple_signal_assignment = 186
    RULE_simple_waveform_assignment = 187
    RULE_simple_force_assignment = 188
    RULE_simple_release_assignment = 189
    RULE_force_mode = 190
    RULE_delay_mechanism = 191
    RULE_target = 192
    RULE_waveform = 193
    RULE_waveform_element = 194
    RULE_conditional_signal_assignment = 195
    RULE_conditional_waveform_assignment = 196
    RULE_conditional_waveforms = 197
    RULE_conditional_force_assignment = 198
    RULE_conditional_expressions = 199
    RULE_selected_signal_assignment = 200
    RULE_selected_waveform_assignment = 201
    RULE_selected_waveforms = 202
    RULE_selected_force_assignment = 203
    RULE_selected_expressions = 204
    RULE_variable_assignment_statement = 205
    RULE_simple_variable_assignment = 206
    RULE_conditional_variable_assignment = 207
    RULE_selected_variable_assignment = 208
    RULE_procedure_call_statement = 209
    RULE_procedure_call = 210
    RULE_if_statement = 211
    RULE_case_statement = 212
    RULE_case_statement_alternative = 213
    RULE_loop_statement = 214
    RULE_iteration_scheme = 215
    RULE_parameter_specification = 216
    RULE_next_statement = 217
    RULE_exit_statement = 218
    RULE_return_statement = 219
    RULE_null_statement = 220
    RULE_concurrent_statement_with_optional_label = 221
    RULE_concurrent_statement = 222
    RULE_block_statement = 223
    RULE_block_header = 224
    RULE_process_statement = 225
    RULE_process_sensitivity_list = 226
    RULE_process_or_package_declarative_item = 227
    RULE_process_declarative_item = 228
    RULE_concurrent_procedure_call_statement = 229
    RULE_concurrent_assertion_statement = 230
    RULE_concurrent_signal_assignment_statement = 231
    RULE_concurrent_signal_assignment_any = 232
    RULE_concurrent_selected_signal_assignment = 233
    RULE_component_instantiation_statement = 234
    RULE_instantiated_unit = 235
    RULE_generate_statement = 236
    RULE_for_generate_statement = 237
    RULE_if_generate_statement = 238
    RULE_case_generate_statement = 239
    RULE_case_generate_alternative = 240
    RULE_generate_statement_body_with_begin_end = 241
    RULE_generate_statement_body = 242
    RULE_label = 243
    RULE_use_clause = 244
    RULE_design_file = 245
    RULE_design_unit = 246
    RULE_library_unit = 247
    RULE_primary_unit = 248
    RULE_secondary_unit = 249
    RULE_library_clause = 250
    RULE_logical_name_list = 251
    RULE_context_declaration = 252
    RULE_context_clause = 253
    RULE_context_item = 254
    RULE_context_reference = 255
    RULE_identifier = 256

    ruleNames =  [ "any_keyword", "name_literal", "name", "name_slice_part", 
                   "name_attribute_part", "attribute_name", "suffix", "explicit_range", 
                   "selected_name", "entity_declaration", "entity_declarative_item", 
                   "entity_statement", "architecture_body", "block_declarative_item", 
                   "configuration_declaration", "configuration_declarative_item", 
                   "block_configuration", "block_specification", "generate_specification", 
                   "configuration_item", "component_configuration", "subprogram_declaration", 
                   "subprogram_specification", "procedure_specification", 
                   "function_specification", "subprogram_header", "designator", 
                   "operator_symbol", "formal_parameter_list", "subprogram_body", 
                   "subprogram_kind", "subprogram_instantiation_declaration", 
                   "signature", "package_declaration", "package_declarative_item", 
                   "package_body", "package_instantiation_declaration", 
                   "scalar_type_definition", "range_constraint", "range_", 
                   "direction", "enumeration_type_definition", "enumeration_literal", 
                   "integer_type_definition", "physical_type_definition", 
                   "primary_unit_declaration", "secondary_unit_declaration", 
                   "floating_type_definition", "composite_type_definition", 
                   "array_type_definition", "unbounded_array_definition", 
                   "constrained_array_definition", "index_subtype_definition", 
                   "array_constraint", "array_element_constraint", "index_constraint", 
                   "discrete_range", "record_type_definition", "element_declaration", 
                   "identifier_list", "element_subtype_definition", "record_constraint", 
                   "record_element_constraint", "access_type_definition", 
                   "incomplete_type_declaration", "file_type_definition", 
                   "protected_type_definition", "protected_type_declaration", 
                   "protected_type_declarative_item", "protected_type_body", 
                   "type_declaration", "full_type_declaration", "type_definition", 
                   "subtype_declaration", "subtype_indication", "resolution_indication", 
                   "element_resolution", "array_element_resolution", "record_resolution", 
                   "record_element_resolution", "type_mark", "constraint", 
                   "element_constraint", "object_declaration", "constant_declaration", 
                   "signal_declaration", "signal_kind", "variable_declaration", 
                   "file_declaration", "file_open_information", "file_logical_name", 
                   "interface_declaration", "interface_object_declaration", 
                   "interface_constant_declaration", "interface_signal_declaration", 
                   "interface_variable_declaration", "interface_file_declaration", 
                   "signal_mode", "interface_type_declaration", "interface_incomplete_type_declaration", 
                   "interface_subprogram_declaration", "interface_subprogram_specification", 
                   "interface_procedure_specification", "interface_function_specification", 
                   "interface_subprogram_default", "interface_package_declaration", 
                   "interface_package_generic_map_aspect", "interface_list", 
                   "interface_element", "generic_clause", "generic_list", 
                   "port_clause", "port_list", "association_list", "association_element", 
                   "formal_part", "actual_part", "actual_designator", "generic_map_aspect", 
                   "port_map_aspect", "alias_declaration", "alias_designator", 
                   "attribute_declaration", "component_declaration", "group_template_declaration", 
                   "entity_class_entry_list", "entity_class_entry", "group_declaration", 
                   "group_constituent_list", "group_constituent", "attribute_specification", 
                   "entity_specification", "entity_class", "entity_name_list", 
                   "entity_designator", "entity_tag", "configuration_specification", 
                   "simple_configuration_specification", "compound_configuration_specification", 
                   "component_specification", "instantiation_list", "binding_indication", 
                   "entity_aspect", "verification_unit_binding_indication", 
                   "verification_unit_list", "disconnection_specification", 
                   "guarded_signal_specification", "signal_list", "attribute_designator", 
                   "external_name", "external_pathname", "package_pathname", 
                   "absolute_pathname", "relative_pathname", "partial_pathname", 
                   "pathname_element", "expression", "simple_expression", 
                   "primary", "logical_operator", "relational_operator", 
                   "shift_operator", "adding_operator", "sign", "multiplying_operator", 
                   "miscellaneous_operator", "numeric_literal", "physical_literal", 
                   "aggregate", "element_association", "choices", "choice", 
                   "qualified_expression", "allocator", "sequence_of_statements", 
                   "sequential_statement", "wait_statement", "sensitivity_clause", 
                   "sensitivity_list", "condition_clause", "condition", 
                   "timeout_clause", "assertion_statement", "assertion", 
                   "report_statement", "signal_assignment_statement", "simple_signal_assignment", 
                   "simple_waveform_assignment", "simple_force_assignment", 
                   "simple_release_assignment", "force_mode", "delay_mechanism", 
                   "target", "waveform", "waveform_element", "conditional_signal_assignment", 
                   "conditional_waveform_assignment", "conditional_waveforms", 
                   "conditional_force_assignment", "conditional_expressions", 
                   "selected_signal_assignment", "selected_waveform_assignment", 
                   "selected_waveforms", "selected_force_assignment", "selected_expressions", 
                   "variable_assignment_statement", "simple_variable_assignment", 
                   "conditional_variable_assignment", "selected_variable_assignment", 
                   "procedure_call_statement", "procedure_call", "if_statement", 
                   "case_statement", "case_statement_alternative", "loop_statement", 
                   "iteration_scheme", "parameter_specification", "next_statement", 
                   "exit_statement", "return_statement", "null_statement", 
                   "concurrent_statement_with_optional_label", "concurrent_statement", 
                   "block_statement", "block_header", "process_statement", 
                   "process_sensitivity_list", "process_or_package_declarative_item", 
                   "process_declarative_item", "concurrent_procedure_call_statement", 
                   "concurrent_assertion_statement", "concurrent_signal_assignment_statement", 
                   "concurrent_signal_assignment_any", "concurrent_selected_signal_assignment", 
                   "component_instantiation_statement", "instantiated_unit", 
                   "generate_statement", "for_generate_statement", "if_generate_statement", 
                   "case_generate_statement", "case_generate_alternative", 
                   "generate_statement_body_with_begin_end", "generate_statement_body", 
                   "label", "use_clause", "design_file", "design_unit", 
                   "library_unit", "primary_unit", "secondary_unit", "library_clause", 
                   "logical_name_list", "context_declaration", "context_clause", 
                   "context_item", "context_reference", "identifier" ]

    EOF = Token.EOF
    KW_PROCESS=1
    KW_CONTEXT=2
    KW_POSTPONED=3
    KW_LINKAGE=4
    KW_COMPONENT=5
    KW_ABS=6
    KW_DEFAULT=7
    KW_THEN=8
    KW_BLOCK=9
    KW_REM=10
    KW_INERTIAL=11
    KW_NEXT=12
    KW_ENTITY=13
    KW_ON=14
    KW_GROUP=15
    KW_XNOR=16
    KW_FILE=17
    KW_PURE=18
    KW_GUARDED=19
    KW_GENERIC=20
    KW_RANGE=21
    KW_ELSE=22
    KW_USE=23
    KW_SHARED=24
    KW_MOD=25
    KW_LOOP=26
    KW_RECORD=27
    KW_SIGNAL=28
    KW_REJECT=29
    KW_BEGIN=30
    KW_SLA=31
    KW_DISCONNECT=32
    KW_OF=33
    KW_PROCEDURE=34
    KW_SRL=35
    KW_VUNIT=36
    KW_ATTRIBUTE=37
    KW_VARIABLE=38
    KW_PROPERTY=39
    KW_UNAFFECTED=40
    KW_XOR=41
    KW_REGISTER=42
    KW_SUBTYPE=43
    KW_TO=44
    KW_NEW=45
    KW_REPORT=46
    KW_CONSTANT=47
    KW_BUFFER=48
    KW_BODY=49
    KW_AFTER=50
    KW_TRANSPORT=51
    KW_FUNCTION=52
    KW_END=53
    KW_SELECT=54
    KW_OR=55
    KW_LIBRARY=56
    KW_ELSIF=57
    KW_SLL=58
    KW_MAP=59
    KW_SRA=60
    KW_PROTECTED=61
    KW_DOWNTO=62
    KW_LABEL=63
    KW_ALL=64
    KW_ALIAS=65
    KW_GENERATE=66
    KW_NOR=67
    KW_IN=68
    KW_RELEASE=69
    KW_EXIT=70
    KW_RETURN=71
    KW_WITH=72
    KW_UNTIL=73
    KW_AND=74
    KW_INOUT=75
    KW_WAIT=76
    KW_NAND=77
    KW_ARRAY=78
    KW_FORCE=79
    KW_WHILE=80
    KW_IMPURE=81
    KW_PACKAGE=82
    KW_UNITS=83
    KW_ASSERT=84
    KW_PARAMETER=85
    KW_SEVERITY=86
    KW_LITERAL=87
    KW_FOR=88
    KW_ROR=89
    KW_IF=90
    KW_OUT=91
    KW_ROL=92
    KW_IS=93
    KW_SEQUENCE=94
    KW_OTHERS=95
    KW_TYPE=96
    KW_CASE=97
    KW_NOT=98
    KW_CONFIGURATION=99
    KW_OPEN=100
    KW_ARCHITECTURE=101
    KW_BUS=102
    KW_ACCESS=103
    KW_WHEN=104
    KW_PORT=105
    KW_NULL=106
    BASIC_IDENTIFIER=107
    EXTENDED_IDENTIFIER=108
    DECIMAL_LITERAL=109
    INTEGER=110
    EXPONENT=111
    BASED_LITERAL=112
    CHARACTER_LITERAL=113
    STRING_LITERAL=114
    BIT_STRING_LITERAL=115
    COMMENT=116
    BLOCK_COMMENT=117
    TAB=118
    SPACE=119
    NEWLINE=120
    CR=121
    SPACE_CHARACTER=122
    DBLQUOTE=123
    UNDERSCORE=124
    DIGIT=125
    SEMI=126
    LPAREN=127
    RPAREN=128
    LSQUARE_BR=129
    RSQUARE_BR=130
    APOSTROPHE=131
    SHIFT_LEFT=132
    SHIFT_RIGHT=133
    AT=134
    HASHTAG=135
    COMMA=136
    DOT=137
    QUESTIONMARK=138
    COLON=139
    EQ=140
    NE=141
    LT=142
    GT=143
    GE=144
    EQ_MATCH=145
    NE_MATCH=146
    LT_MATCH=147
    LE_MATCH=148
    GT_MATCH=149
    GE_MATCH=150
    PLUS=151
    MINUS=152
    AMPERSAND=153
    BAR=154
    BACKSLASH=155
    MUL=156
    DIV=157
    DOUBLESTAR=158
    CONASGN=159
    GRAVE_ACCENT=160
    UP=161
    VARASGN=162
    BOX=163
    ARROW=164
    COND_OP=165

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




    class Any_keywordContext(ParserRuleContext):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_any_keyword

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

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

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




    def any_keyword(self):

        localctx = vhdlParser.Any_keywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_any_keyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_PROCESS) | (1 << vhdlParser.KW_CONTEXT) | (1 << vhdlParser.KW_POSTPONED) | (1 << vhdlParser.KW_LINKAGE) | (1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_ABS) | (1 << vhdlParser.KW_DEFAULT) | (1 << vhdlParser.KW_THEN) | (1 << vhdlParser.KW_BLOCK) | (1 << vhdlParser.KW_REM) | (1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_NEXT) | (1 << vhdlParser.KW_ENTITY) | (1 << vhdlParser.KW_ON) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_XNOR) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_GUARDED) | (1 << vhdlParser.KW_GENERIC) | (1 << vhdlParser.KW_RANGE) | (1 << vhdlParser.KW_ELSE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_MOD) | (1 << vhdlParser.KW_LOOP) | (1 << vhdlParser.KW_RECORD) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_BEGIN) | (1 << vhdlParser.KW_SLA) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_OF) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_SRL) | (1 << vhdlParser.KW_VUNIT) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_PROPERTY) | (1 << vhdlParser.KW_UNAFFECTED) | (1 << vhdlParser.KW_XOR) | (1 << vhdlParser.KW_REGISTER) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_TO) | (1 << vhdlParser.KW_NEW) | (1 << vhdlParser.KW_REPORT) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_BUFFER) | (1 << vhdlParser.KW_BODY) | (1 << vhdlParser.KW_AFTER) | (1 << vhdlParser.KW_TRANSPORT) | (1 << vhdlParser.KW_FUNCTION) | (1 << vhdlParser.KW_END) | (1 << vhdlParser.KW_SELECT) | (1 << vhdlParser.KW_OR) | (1 << vhdlParser.KW_LIBRARY) | (1 << vhdlParser.KW_ELSIF) | (1 << vhdlParser.KW_SLL) | (1 << vhdlParser.KW_MAP) | (1 << vhdlParser.KW_SRA) | (1 << vhdlParser.KW_PROTECTED) | (1 << vhdlParser.KW_DOWNTO) | (1 << vhdlParser.KW_LABEL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vhdlParser.KW_ALL - 64)) | (1 << (vhdlParser.KW_ALIAS - 64)) | (1 << (vhdlParser.KW_GENERATE - 64)) | (1 << (vhdlParser.KW_NOR - 64)) | (1 << (vhdlParser.KW_IN - 64)) | (1 << (vhdlParser.KW_RELEASE - 64)) | (1 << (vhdlParser.KW_EXIT - 64)) | (1 << (vhdlParser.KW_RETURN - 64)) | (1 << (vhdlParser.KW_WITH - 64)) | (1 << (vhdlParser.KW_UNTIL - 64)) | (1 << (vhdlParser.KW_AND - 64)) | (1 << (vhdlParser.KW_INOUT - 64)) | (1 << (vhdlParser.KW_WAIT - 64)) | (1 << (vhdlParser.KW_NAND - 64)) | (1 << (vhdlParser.KW_ARRAY - 64)) | (1 << (vhdlParser.KW_FORCE - 64)) | (1 << (vhdlParser.KW_WHILE - 64)) | (1 << (vhdlParser.KW_IMPURE - 64)) | (1 << (vhdlParser.KW_PACKAGE - 64)) | (1 << (vhdlParser.KW_UNITS - 64)) | (1 << (vhdlParser.KW_ASSERT - 64)) | (1 << (vhdlParser.KW_PARAMETER - 64)) | (1 << (vhdlParser.KW_SEVERITY - 64)) | (1 << (vhdlParser.KW_LITERAL - 64)) | (1 << (vhdlParser.KW_FOR - 64)) | (1 << (vhdlParser.KW_ROR - 64)) | (1 << (vhdlParser.KW_IF - 64)) | (1 << (vhdlParser.KW_OUT - 64)) | (1 << (vhdlParser.KW_ROL - 64)) | (1 << (vhdlParser.KW_IS - 64)) | (1 << (vhdlParser.KW_SEQUENCE - 64)) | (1 << (vhdlParser.KW_OTHERS - 64)) | (1 << (vhdlParser.KW_TYPE - 64)) | (1 << (vhdlParser.KW_CASE - 64)) | (1 << (vhdlParser.KW_NOT - 64)) | (1 << (vhdlParser.KW_CONFIGURATION - 64)) | (1 << (vhdlParser.KW_OPEN - 64)) | (1 << (vhdlParser.KW_ARCHITECTURE - 64)) | (1 << (vhdlParser.KW_BUS - 64)) | (1 << (vhdlParser.KW_ACCESS - 64)) | (1 << (vhdlParser.KW_WHEN - 64)) | (1 << (vhdlParser.KW_PORT - 64)) | (1 << (vhdlParser.KW_NULL - 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 Name_literalContext(ParserRuleContext):

        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 operator_symbol(self):
            return self.getTypedRuleContext(vhdlParser.Operator_symbolContext,0)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_name_literal

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

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

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




    def name_literal(self):

        localctx = vhdlParser.Name_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_name_literal)
        try:
            self.state = 519
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 516
                self.identifier()
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 517
                self.operator_symbol()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 518
                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 NameContext(ParserRuleContext):

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

        def name_literal(self):
            return self.getTypedRuleContext(vhdlParser.Name_literalContext,0)


        def external_name(self):
            return self.getTypedRuleContext(vhdlParser.External_nameContext,0)


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


        def name_slice_part(self):
            return self.getTypedRuleContext(vhdlParser.Name_slice_partContext,0)


        def name_attribute_part(self):
            return self.getTypedRuleContext(vhdlParser.Name_attribute_partContext,0)


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


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

        def suffix(self):
            return self.getTypedRuleContext(vhdlParser.SuffixContext,0)


        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, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = vhdlParser.NameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 4
        self.enterRecursionRule(localctx, 4, self.RULE_name, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524
            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.state = 522
                self.name_literal()
                pass
            elif token in [vhdlParser.SHIFT_LEFT]:
                self.state = 523
                self.external_name()
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 536
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = vhdlParser.NameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_name)
                    self.state = 526
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 532
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                    if la_ == 1:
                        self.state = 527
                        self.name_slice_part()
                        pass

                    elif la_ == 2:
                        self.state = 528
                        self.name_attribute_part()
                        pass

                    elif la_ == 3:
                        self.state = 529
                        self.association_list()
                        pass

                    elif la_ == 4:
                        self.state = 530
                        self.match(vhdlParser.DOT)
                        self.state = 531
                        self.suffix()
                        pass

             
                self.state = 538
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

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


    class Name_slice_partContext(ParserRuleContext):

        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 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_name_slice_part

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

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

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




    def name_slice_part(self):

        localctx = vhdlParser.Name_slice_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_name_slice_part)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self.match(vhdlParser.LPAREN)
            self.state = 540
            self.explicit_range()
            self.state = 541
            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 Name_attribute_partContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_name_attribute_part

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

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

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




    def name_attribute_part(self):

        localctx = vhdlParser.Name_attribute_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_name_attribute_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LSQUARE_BR:
                self.state = 543
                self.signature()


            self.state = 546
            self.match(vhdlParser.APOSTROPHE)
            self.state = 547
            self.attribute_designator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_nameContext(ParserRuleContext):

        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 name_attribute_part(self):
            return self.getTypedRuleContext(vhdlParser.Name_attribute_partContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_attribute_name

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

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

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




    def attribute_name(self):

        localctx = vhdlParser.Attribute_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_attribute_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 549
            self.name(0)
            self.state = 550
            self.name_attribute_part()
        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):

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

        def name_literal(self):
            return self.getTypedRuleContext(vhdlParser.Name_literalContext,0)


        def KW_ALL(self):
            return self.getToken(vhdlParser.KW_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, 12, self.RULE_suffix)
        try:
            self.state = 554
            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 = 552
                self.name_literal()
                pass
            elif token in [vhdlParser.KW_ALL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 553
                self.match(vhdlParser.KW_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 Explicit_rangeContext(ParserRuleContext):

        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, 14, self.RULE_explicit_range)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 556
            self.simple_expression(0)
            self.state = 557
            self.direction()
            self.state = 558
            self.simple_expression(0)
        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):

        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, 16, self.RULE_selected_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            self.identifier()
            self.state = 565
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.DOT:
                self.state = 561
                self.match(vhdlParser.DOT)
                self.state = 562
                self.suffix()
                self.state = 567
                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):

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

        def KW_ENTITY(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_ENTITY)
            else:
                return self.getToken(vhdlParser.KW_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 KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 0)

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

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

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


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


        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 KW_BEGIN(self):
            return self.getToken(vhdlParser.KW_BEGIN, 0)

        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_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, 18, self.RULE_entity_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self.match(vhdlParser.KW_ENTITY)
            self.state = 569
            self.identifier()
            self.state = 570
            self.match(vhdlParser.KW_IS)
            self.state = 572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 571
                self.generic_clause()


            self.state = 575
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PORT:
                self.state = 574
                self.port_clause()


            self.state = 580
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 577
                self.entity_declarative_item()
                self.state = 582
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 590
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_BEGIN:
                self.state = 583
                self.match(vhdlParser.KW_BEGIN)
                self.state = 587
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.KW_PROCESS or _la==vhdlParser.KW_POSTPONED or ((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (vhdlParser.KW_ASSERT - 84)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 84)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 84)) | (1 << (vhdlParser.CHARACTER_LITERAL - 84)) | (1 << (vhdlParser.STRING_LITERAL - 84)) | (1 << (vhdlParser.SHIFT_LEFT - 84)))) != 0):
                    self.state = 584
                    self.entity_statement()
                    self.state = 589
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 592
            self.match(vhdlParser.KW_END)
            self.state = 594
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_ENTITY:
                self.state = 593
                self.match(vhdlParser.KW_ENTITY)


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


            self.state = 599
            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):

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

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


        def process_declarative_item(self):
            return self.getTypedRuleContext(vhdlParser.Process_declarative_itemContext,0)


        def disconnection_specification(self):
            return self.getTypedRuleContext(vhdlParser.Disconnection_specificationContext,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, 20, self.RULE_entity_declarative_item)
        try:
            self.state = 604
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_SIGNAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 601
                self.signal_declaration()
                pass
            elif token in [vhdlParser.KW_GROUP, vhdlParser.KW_FILE, vhdlParser.KW_PURE, vhdlParser.KW_USE, vhdlParser.KW_SHARED, vhdlParser.KW_PROCEDURE, vhdlParser.KW_ATTRIBUTE, vhdlParser.KW_VARIABLE, vhdlParser.KW_SUBTYPE, vhdlParser.KW_CONSTANT, vhdlParser.KW_FUNCTION, vhdlParser.KW_ALIAS, vhdlParser.KW_IMPURE, vhdlParser.KW_PACKAGE, vhdlParser.KW_TYPE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 602
                self.process_declarative_item()
                pass
            elif token in [vhdlParser.KW_DISCONNECT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 603
                self.disconnection_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 Entity_statementContext(ParserRuleContext):

        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 concurrent_procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_procedure_call_statementContext,0)


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


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 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, 22, self.RULE_entity_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 609
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 606
                self.label()
                self.state = 607
                self.match(vhdlParser.COLON)


            self.state = 614
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.state = 611
                self.concurrent_assertion_statement()
                pass

            elif la_ == 2:
                self.state = 612
                self.concurrent_procedure_call_statement()
                pass

            elif la_ == 3:
                self.state = 613
                self.process_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_bodyContext(ParserRuleContext):

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

        def KW_ARCHITECTURE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_ARCHITECTURE)
            else:
                return self.getToken(vhdlParser.KW_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 KW_OF(self):
            return self.getToken(vhdlParser.KW_OF, 0)

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


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

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

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

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 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 concurrent_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Concurrent_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Concurrent_statementContext,i)


        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 = 616
            self.match(vhdlParser.KW_ARCHITECTURE)
            self.state = 617
            self.identifier()
            self.state = 618
            self.match(vhdlParser.KW_OF)
            self.state = 619
            self.name(0)
            self.state = 620
            self.match(vhdlParser.KW_IS)
            self.state = 624
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_FOR - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 621
                self.block_declarative_item()
                self.state = 626
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 627
            self.match(vhdlParser.KW_BEGIN)
            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_PROCESS or _la==vhdlParser.KW_POSTPONED or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (vhdlParser.KW_WITH - 72)) | (1 << (vhdlParser.KW_ASSERT - 72)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 72)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 72)) | (1 << (vhdlParser.CHARACTER_LITERAL - 72)) | (1 << (vhdlParser.STRING_LITERAL - 72)) | (1 << (vhdlParser.LPAREN - 72)) | (1 << (vhdlParser.SHIFT_LEFT - 72)))) != 0):
                self.state = 628
                self.concurrent_statement()
                self.state = 633
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 634
            self.match(vhdlParser.KW_END)
            self.state = 636
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_ARCHITECTURE:
                self.state = 635
                self.match(vhdlParser.KW_ARCHITECTURE)


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


            self.state = 641
            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):

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

        def entity_declarative_item(self):
            return self.getTypedRuleContext(vhdlParser.Entity_declarative_itemContext,0)


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


        def configuration_specification(self):
            return self.getTypedRuleContext(vhdlParser.Configuration_specificationContext,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, 26, self.RULE_block_declarative_item)
        try:
            self.state = 646
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_GROUP, vhdlParser.KW_FILE, vhdlParser.KW_PURE, vhdlParser.KW_USE, vhdlParser.KW_SHARED, vhdlParser.KW_SIGNAL, vhdlParser.KW_DISCONNECT, vhdlParser.KW_PROCEDURE, vhdlParser.KW_ATTRIBUTE, vhdlParser.KW_VARIABLE, vhdlParser.KW_SUBTYPE, vhdlParser.KW_CONSTANT, vhdlParser.KW_FUNCTION, vhdlParser.KW_ALIAS, vhdlParser.KW_IMPURE, vhdlParser.KW_PACKAGE, vhdlParser.KW_TYPE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 643
                self.entity_declarative_item()
                pass
            elif token in [vhdlParser.KW_COMPONENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 644
                self.component_declaration()
                pass
            elif token in [vhdlParser.KW_FOR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 645
                self.configuration_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 Configuration_declarationContext(ParserRuleContext):

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

        def KW_CONFIGURATION(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_CONFIGURATION)
            else:
                return self.getToken(vhdlParser.KW_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 KW_OF(self):
            return self.getToken(vhdlParser.KW_OF, 0)

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


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

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


        def KW_END(self):
            return self.getToken(vhdlParser.KW_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 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 verification_unit_binding_indication(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Verification_unit_binding_indicationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Verification_unit_binding_indicationContext,i)


        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, 28, self.RULE_configuration_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(vhdlParser.KW_CONFIGURATION)
            self.state = 649
            self.identifier()
            self.state = 650
            self.match(vhdlParser.KW_OF)
            self.state = 651
            self.name(0)
            self.state = 652
            self.match(vhdlParser.KW_IS)
            self.state = 656
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 653
                    self.configuration_declarative_item() 
                self.state = 658
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

            self.state = 664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_USE:
                self.state = 659
                self.verification_unit_binding_indication()
                self.state = 660
                self.match(vhdlParser.SEMI)
                self.state = 666
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 667
            self.block_configuration()
            self.state = 668
            self.match(vhdlParser.KW_END)
            self.state = 670
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_CONFIGURATION:
                self.state = 669
                self.match(vhdlParser.KW_CONFIGURATION)


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


            self.state = 675
            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):

        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, 30, self.RULE_configuration_declarative_item)
        try:
            self.state = 680
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_USE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 677
                self.use_clause()
                pass
            elif token in [vhdlParser.KW_ATTRIBUTE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 678
                self.attribute_specification()
                pass
            elif token in [vhdlParser.KW_GROUP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 679
                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 Block_configurationContext(ParserRuleContext):

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

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

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


        def KW_END(self):
            return self.getToken(vhdlParser.KW_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, 32, self.RULE_block_configuration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 682
            self.match(vhdlParser.KW_FOR)
            self.state = 683
            self.block_specification()
            self.state = 687
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_USE:
                self.state = 684
                self.use_clause()
                self.state = 689
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_FOR:
                self.state = 690
                self.configuration_item()
                self.state = 695
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 696
            self.match(vhdlParser.KW_END)
            self.state = 697
            self.match(vhdlParser.KW_FOR)
            self.state = 698
            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):

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


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

        def generate_specification(self):
            return self.getTypedRuleContext(vhdlParser.Generate_specificationContext,0)


        def RPAREN(self):
            return self.getToken(vhdlParser.RPAREN, 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, 34, self.RULE_block_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 700
            self.label()
            self.state = 705
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 701
                self.match(vhdlParser.LPAREN)
                self.state = 702
                self.generate_specification()
                self.state = 703
                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 Generate_specificationContext(ParserRuleContext):

        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 label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_generate_specification

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

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

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




    def generate_specification(self):

        localctx = vhdlParser.Generate_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_generate_specification)
        try:
            self.state = 710
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 707
                self.discrete_range()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.expression(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 709
                self.label()
                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_itemContext(ParserRuleContext):

        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, 38, self.RULE_configuration_item)
        try:
            self.state = 714
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 712
                self.block_configuration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 713
                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 Component_configurationContext(ParserRuleContext):

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

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

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


        def KW_END(self):
            return self.getToken(vhdlParser.KW_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 verification_unit_binding_indication(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Verification_unit_binding_indicationContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Verification_unit_binding_indicationContext,i)


        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, 40, self.RULE_component_configuration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            self.match(vhdlParser.KW_FOR)
            self.state = 717
            self.component_specification()
            self.state = 721
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.state = 718
                self.binding_indication()
                self.state = 719
                self.match(vhdlParser.SEMI)


            self.state = 728
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_USE:
                self.state = 723
                self.verification_unit_binding_indication()
                self.state = 724
                self.match(vhdlParser.SEMI)
                self.state = 730
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 732
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_FOR:
                self.state = 731
                self.block_configuration()


            self.state = 734
            self.match(vhdlParser.KW_END)
            self.state = 735
            self.match(vhdlParser.KW_FOR)
            self.state = 736
            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):

        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, 42, self.RULE_subprogram_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 738
            self.subprogram_specification()
            self.state = 739
            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_specificationContext(ParserRuleContext):

        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, 44, self.RULE_subprogram_specification)
        try:
            self.state = 743
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_PROCEDURE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 741
                self.procedure_specification()
                pass
            elif token in [vhdlParser.KW_PURE, vhdlParser.KW_FUNCTION, vhdlParser.KW_IMPURE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 742
                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):

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

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

        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


        def subprogram_header(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_headerContext,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 KW_PARAMETER(self):
            return self.getToken(vhdlParser.KW_PARAMETER, 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, 46, self.RULE_procedure_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 745
            self.match(vhdlParser.KW_PROCEDURE)
            self.state = 746
            self.designator()
            self.state = 748
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 747
                self.subprogram_header()


            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PARAMETER or _la==vhdlParser.LPAREN:
                self.state = 751
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_PARAMETER:
                    self.state = 750
                    self.match(vhdlParser.KW_PARAMETER)


                self.state = 753
                self.match(vhdlParser.LPAREN)
                self.state = 754
                self.formal_parameter_list()
                self.state = 755
                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):

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

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

        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,0)


        def subprogram_header(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_headerContext,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 KW_PURE(self):
            return self.getToken(vhdlParser.KW_PURE, 0)

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

        def KW_PARAMETER(self):
            return self.getToken(vhdlParser.KW_PARAMETER, 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, 48, self.RULE_function_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 760
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PURE or _la==vhdlParser.KW_IMPURE:
                self.state = 759
                _la = self._input.LA(1)
                if not(_la==vhdlParser.KW_PURE or _la==vhdlParser.KW_IMPURE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 762
            self.match(vhdlParser.KW_FUNCTION)
            self.state = 763
            self.designator()
            self.state = 765
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 764
                self.subprogram_header()


            self.state = 774
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PARAMETER or _la==vhdlParser.LPAREN:
                self.state = 768
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_PARAMETER:
                    self.state = 767
                    self.match(vhdlParser.KW_PARAMETER)


                self.state = 770
                self.match(vhdlParser.LPAREN)
                self.state = 771
                self.formal_parameter_list()
                self.state = 772
                self.match(vhdlParser.RPAREN)


            self.state = 776
            self.match(vhdlParser.KW_RETURN)
            self.state = 777
            self.type_mark()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subprogram_headerContext(ParserRuleContext):

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

        def KW_GENERIC(self):
            return self.getToken(vhdlParser.KW_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 generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Generic_map_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_header

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

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

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




    def subprogram_header(self):

        localctx = vhdlParser.Subprogram_headerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_subprogram_header)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self.match(vhdlParser.KW_GENERIC)
            self.state = 780
            self.match(vhdlParser.LPAREN)
            self.state = 781
            self.generic_list()
            self.state = 782
            self.match(vhdlParser.RPAREN)
            self.state = 784
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 783
                self.generic_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 DesignatorContext(ParserRuleContext):

        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 operator_symbol(self):
            return self.getTypedRuleContext(vhdlParser.Operator_symbolContext,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, 52, self.RULE_designator)
        try:
            self.state = 788
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 786
                self.identifier()
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 787
                self.operator_symbol()
                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 Operator_symbolContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_operator_symbol

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

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

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




    def operator_symbol(self):

        localctx = vhdlParser.Operator_symbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_operator_symbol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 790
            self.match(vhdlParser.STRING_LITERAL)
        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):

        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, 56, self.RULE_formal_parameter_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 792
            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 Subprogram_bodyContext(ParserRuleContext):

        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 KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 0)

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

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

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

        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 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 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, 58, self.RULE_subprogram_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 794
            self.subprogram_specification()
            self.state = 795
            self.match(vhdlParser.KW_IS)
            self.state = 799
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 796
                self.process_declarative_item()
                self.state = 801
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 802
            self.match(vhdlParser.KW_BEGIN)
            self.state = 806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_NEXT) | (1 << vhdlParser.KW_LOOP) | (1 << vhdlParser.KW_REPORT))) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (vhdlParser.KW_EXIT - 70)) | (1 << (vhdlParser.KW_RETURN - 70)) | (1 << (vhdlParser.KW_WITH - 70)) | (1 << (vhdlParser.KW_WAIT - 70)) | (1 << (vhdlParser.KW_WHILE - 70)) | (1 << (vhdlParser.KW_ASSERT - 70)) | (1 << (vhdlParser.KW_FOR - 70)) | (1 << (vhdlParser.KW_IF - 70)) | (1 << (vhdlParser.KW_CASE - 70)) | (1 << (vhdlParser.KW_NULL - 70)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 70)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 70)) | (1 << (vhdlParser.CHARACTER_LITERAL - 70)) | (1 << (vhdlParser.STRING_LITERAL - 70)) | (1 << (vhdlParser.LPAREN - 70)) | (1 << (vhdlParser.SHIFT_LEFT - 70)))) != 0):
                self.state = 803
                self.sequential_statement()
                self.state = 808
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 809
            self.match(vhdlParser.KW_END)
            self.state = 811
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PROCEDURE or _la==vhdlParser.KW_FUNCTION:
                self.state = 810
                self.subprogram_kind()


            self.state = 814
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 107)) & ~0x3f) == 0 and ((1 << (_la - 107)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 107)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 107)) | (1 << (vhdlParser.STRING_LITERAL - 107)))) != 0):
                self.state = 813
                self.designator()


            self.state = 816
            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_kindContext(ParserRuleContext):

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

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

        def KW_FUNCTION(self):
            return self.getToken(vhdlParser.KW_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, 60, self.RULE_subprogram_kind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_PROCEDURE or _la==vhdlParser.KW_FUNCTION):
                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_instantiation_declarationContext(ParserRuleContext):

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

        def subprogram_kind(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_kindContext,0)


        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


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

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

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


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

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


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


        def getRuleIndex(self):
            return vhdlParser.RULE_subprogram_instantiation_declaration

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

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

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




    def subprogram_instantiation_declaration(self):

        localctx = vhdlParser.Subprogram_instantiation_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_subprogram_instantiation_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 820
            self.subprogram_kind()
            self.state = 821
            self.designator()
            self.state = 822
            self.match(vhdlParser.KW_IS)
            self.state = 823
            self.match(vhdlParser.KW_NEW)
            self.state = 824
            self.name(0)
            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LSQUARE_BR:
                self.state = 825
                self.signature()


            self.state = 829
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 828
                self.generic_map_aspect()


            self.state = 831
            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 SignatureContext(ParserRuleContext):

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

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

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

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


        def KW_RETURN(self):
            return self.getToken(vhdlParser.KW_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, 64, self.RULE_signature)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 833
            self.match(vhdlParser.LSQUARE_BR)
            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 107)) & ~0x3f) == 0 and ((1 << (_la - 107)) & ((1 << (vhdlParser.BASIC_IDENTIFIER - 107)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 107)) | (1 << (vhdlParser.CHARACTER_LITERAL - 107)) | (1 << (vhdlParser.STRING_LITERAL - 107)) | (1 << (vhdlParser.SHIFT_LEFT - 107)))) != 0):
                self.state = 834
                self.type_mark()
                self.state = 839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 835
                    self.match(vhdlParser.COMMA)
                    self.state = 836
                    self.type_mark()
                    self.state = 841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 846
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_RETURN:
                self.state = 844
                self.match(vhdlParser.KW_RETURN)
                self.state = 845
                self.type_mark()


            self.state = 848
            self.match(vhdlParser.RSQUARE_BR)
        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):

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

        def KW_PACKAGE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_PACKAGE)
            else:
                return self.getToken(vhdlParser.KW_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 KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 0)

        def KW_END(self):
            return self.getToken(vhdlParser.KW_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 generic_clause(self):
            return self.getTypedRuleContext(vhdlParser.Generic_clauseContext,0)


        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 generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Generic_map_aspectContext,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, 66, self.RULE_package_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 850
            self.match(vhdlParser.KW_PACKAGE)
            self.state = 851
            self.identifier()
            self.state = 852
            self.match(vhdlParser.KW_IS)
            self.state = 859
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 853
                self.generic_clause()
                self.state = 857
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_GENERIC:
                    self.state = 854
                    self.generic_map_aspect()
                    self.state = 855
                    self.match(vhdlParser.SEMI)




            self.state = 864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 861
                self.package_declarative_item()
                self.state = 866
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 867
            self.match(vhdlParser.KW_END)
            self.state = 869
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PACKAGE:
                self.state = 868
                self.match(vhdlParser.KW_PACKAGE)


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


            self.state = 874
            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):

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

        def process_or_package_declarative_item(self):
            return self.getTypedRuleContext(vhdlParser.Process_or_package_declarative_itemContext,0)


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


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


        def disconnection_specification(self):
            return self.getTypedRuleContext(vhdlParser.Disconnection_specificationContext,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, 68, self.RULE_package_declarative_item)
        try:
            self.state = 880
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_GROUP, vhdlParser.KW_FILE, vhdlParser.KW_PURE, vhdlParser.KW_USE, vhdlParser.KW_SHARED, vhdlParser.KW_PROCEDURE, vhdlParser.KW_ATTRIBUTE, vhdlParser.KW_VARIABLE, vhdlParser.KW_SUBTYPE, vhdlParser.KW_CONSTANT, vhdlParser.KW_FUNCTION, vhdlParser.KW_ALIAS, vhdlParser.KW_IMPURE, vhdlParser.KW_PACKAGE, vhdlParser.KW_TYPE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 876
                self.process_or_package_declarative_item()
                pass
            elif token in [vhdlParser.KW_SIGNAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 877
                self.signal_declaration()
                pass
            elif token in [vhdlParser.KW_COMPONENT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 878
                self.component_declaration()
                pass
            elif token in [vhdlParser.KW_DISCONNECT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 879
                self.disconnection_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 Package_bodyContext(ParserRuleContext):

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

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

        def KW_BODY(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_BODY)
            else:
                return self.getToken(vhdlParser.KW_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 KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 0)

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

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

        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_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, 70, self.RULE_package_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 882
            self.match(vhdlParser.KW_PACKAGE)
            self.state = 883
            self.match(vhdlParser.KW_BODY)
            self.state = 884
            self.identifier()
            self.state = 885
            self.match(vhdlParser.KW_IS)
            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 886
                self.process_declarative_item()
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 892
            self.match(vhdlParser.KW_END)
            self.state = 895
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PACKAGE:
                self.state = 893
                self.match(vhdlParser.KW_PACKAGE)
                self.state = 894
                self.match(vhdlParser.KW_BODY)


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


            self.state = 900
            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_instantiation_declarationContext(ParserRuleContext):

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

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

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


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

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

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


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

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


        def getRuleIndex(self):
            return vhdlParser.RULE_package_instantiation_declaration

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

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

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




    def package_instantiation_declaration(self):

        localctx = vhdlParser.Package_instantiation_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_package_instantiation_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 902
            self.match(vhdlParser.KW_PACKAGE)
            self.state = 903
            self.identifier()
            self.state = 904
            self.match(vhdlParser.KW_IS)
            self.state = 905
            self.match(vhdlParser.KW_NEW)
            self.state = 906
            self.name(0)
            self.state = 908
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 907
                self.generic_map_aspect()


            self.state = 910
            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_type_definitionContext(ParserRuleContext):

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

        def enumeration_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Enumeration_type_definitionContext,0)


        def integer_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Integer_type_definitionContext,0)


        def floating_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Floating_type_definitionContext,0)


        def physical_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Physical_type_definitionContext,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, 74, self.RULE_scalar_type_definition)
        try:
            self.state = 916
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 912
                self.enumeration_type_definition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 913
                self.integer_type_definition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 914
                self.floating_type_definition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 915
                self.physical_type_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 Range_constraintContext(ParserRuleContext):

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

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

        def range_(self):
            return self.getTypedRuleContext(vhdlParser.Range_Context,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, 76, self.RULE_range_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            self.match(vhdlParser.KW_RANGE)
            self.state = 919
            self.range_()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Range_Context(ParserRuleContext):

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

        def attribute_name(self):
            return self.getTypedRuleContext(vhdlParser.Attribute_nameContext,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 direction(self):
            return self.getTypedRuleContext(vhdlParser.DirectionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_range_

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

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

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




    def range_(self):

        localctx = vhdlParser.Range_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_range_)
        try:
            self.state = 926
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 921
                self.attribute_name()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 922
                self.simple_expression(0)
                self.state = 923
                self.direction()
                self.state = 924
                self.simple_expression(0)
                pass


        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):

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

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

        def KW_DOWNTO(self):
            return self.getToken(vhdlParser.KW_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, 80, self.RULE_direction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 928
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_TO or _la==vhdlParser.KW_DOWNTO):
                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 Enumeration_type_definitionContext(ParserRuleContext):

        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, 82, self.RULE_enumeration_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 930
            self.match(vhdlParser.LPAREN)
            self.state = 931
            self.enumeration_literal()
            self.state = 936
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 932
                self.match(vhdlParser.COMMA)
                self.state = 933
                self.enumeration_literal()
                self.state = 938
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 939
            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 Enumeration_literalContext(ParserRuleContext):

        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, 84, self.RULE_enumeration_literal)
        try:
            self.state = 943
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 941
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 942
                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 Integer_type_definitionContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_integer_type_definition

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

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

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




    def integer_type_definition(self):

        localctx = vhdlParser.Integer_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_integer_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 945
            self.range_constraint()
        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):

        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 KW_UNITS(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_UNITS)
            else:
                return self.getToken(vhdlParser.KW_UNITS, i)

        def primary_unit_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Primary_unit_declarationContext,0)


        def KW_END(self):
            return self.getToken(vhdlParser.KW_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, 88, self.RULE_physical_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 947
            self.range_constraint()
            self.state = 948
            self.match(vhdlParser.KW_UNITS)
            self.state = 949
            self.primary_unit_declaration()
            self.state = 953
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 950
                self.secondary_unit_declaration()
                self.state = 955
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 956
            self.match(vhdlParser.KW_END)
            self.state = 957
            self.match(vhdlParser.KW_UNITS)
            self.state = 959
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 958
                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 Primary_unit_declarationContext(ParserRuleContext):

        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_primary_unit_declaration

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

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

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




    def primary_unit_declaration(self):

        localctx = vhdlParser.Primary_unit_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_primary_unit_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 961
            self.identifier()
            self.state = 962
            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 Secondary_unit_declarationContext(ParserRuleContext):

        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, 92, self.RULE_secondary_unit_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 964
            self.identifier()
            self.state = 965
            self.match(vhdlParser.EQ)
            self.state = 966
            self.physical_literal()
            self.state = 967
            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 Floating_type_definitionContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_floating_type_definition

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

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

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




    def floating_type_definition(self):

        localctx = vhdlParser.Floating_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_floating_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 969
            self.range_constraint()
        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):

        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 = 973
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_ARRAY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 971
                self.array_type_definition()
                pass
            elif token in [vhdlParser.KW_RECORD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 972
                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 Array_type_definitionContext(ParserRuleContext):

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

        def unbounded_array_definition(self):
            return self.getTypedRuleContext(vhdlParser.Unbounded_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, 98, self.RULE_array_type_definition)
        try:
            self.state = 977
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 975
                self.unbounded_array_definition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 976
                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 Unbounded_array_definitionContext(ParserRuleContext):

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

        def KW_ARRAY(self):
            return self.getToken(vhdlParser.KW_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 KW_OF(self):
            return self.getToken(vhdlParser.KW_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_unbounded_array_definition

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

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

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




    def unbounded_array_definition(self):

        localctx = vhdlParser.Unbounded_array_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_unbounded_array_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 979
            self.match(vhdlParser.KW_ARRAY)
            self.state = 980
            self.match(vhdlParser.LPAREN)
            self.state = 981
            self.index_subtype_definition()
            self.state = 986
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 982
                self.match(vhdlParser.COMMA)
                self.state = 983
                self.index_subtype_definition()
                self.state = 988
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 989
            self.match(vhdlParser.RPAREN)
            self.state = 990
            self.match(vhdlParser.KW_OF)
            self.state = 991
            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_array_definitionContext(ParserRuleContext):

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

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

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


        def KW_OF(self):
            return self.getToken(vhdlParser.KW_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, 102, self.RULE_constrained_array_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 993
            self.match(vhdlParser.KW_ARRAY)
            self.state = 994
            self.index_constraint()
            self.state = 995
            self.match(vhdlParser.KW_OF)
            self.state = 996
            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 Index_subtype_definitionContext(ParserRuleContext):

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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,0)


        def KW_RANGE(self):
            return self.getToken(vhdlParser.KW_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, 104, self.RULE_index_subtype_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 998
            self.type_mark()
            self.state = 999
            self.match(vhdlParser.KW_RANGE)
            self.state = 1000
            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 Array_constraintContext(ParserRuleContext):

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

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


        def array_element_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Array_element_constraintContext,0)


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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_array_constraint

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

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

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




    def array_constraint(self):

        localctx = vhdlParser.Array_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_array_constraint)
        try:
            self.state = 1012
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1002
                self.index_constraint()
                self.state = 1004
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 1003
                    self.array_element_constraint()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1006
                self.match(vhdlParser.LPAREN)
                self.state = 1007
                self.match(vhdlParser.KW_OPEN)
                self.state = 1008
                self.match(vhdlParser.RPAREN)
                self.state = 1010
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                if la_ == 1:
                    self.state = 1009
                    self.array_element_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 Array_element_constraintContext(ParserRuleContext):

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

        def element_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Element_constraintContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_array_element_constraint

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

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

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




    def array_element_constraint(self):

        localctx = vhdlParser.Array_element_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_array_element_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1014
            self.element_constraint()
        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):

        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, 110, self.RULE_index_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1016
            self.match(vhdlParser.LPAREN)
            self.state = 1017
            self.discrete_range()
            self.state = 1022
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1018
                self.match(vhdlParser.COMMA)
                self.state = 1019
                self.discrete_range()
                self.state = 1024
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1025
            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 Discrete_rangeContext(ParserRuleContext):

        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 range_(self):
            return self.getTypedRuleContext(vhdlParser.Range_Context,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, 112, self.RULE_discrete_range)
        try:
            self.state = 1029
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1027
                self.subtype_indication()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1028
                self.range_()
                pass


        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):

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

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

        def KW_END(self):
            return self.getToken(vhdlParser.KW_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, 114, self.RULE_record_type_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1031
            self.match(vhdlParser.KW_RECORD)
            self.state = 1033 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1032
                self.element_declaration()
                self.state = 1035 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER):
                    break

            self.state = 1037
            self.match(vhdlParser.KW_END)
            self.state = 1038
            self.match(vhdlParser.KW_RECORD)
            self.state = 1040
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1039
                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 Element_declarationContext(ParserRuleContext):

        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, 116, self.RULE_element_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1042
            self.identifier_list()
            self.state = 1043
            self.match(vhdlParser.COLON)
            self.state = 1044
            self.element_subtype_definition()
            self.state = 1045
            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 Identifier_listContext(ParserRuleContext):

        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, 118, self.RULE_identifier_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1047
            self.identifier()
            self.state = 1052
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1048
                self.match(vhdlParser.COMMA)
                self.state = 1049
                self.identifier()
                self.state = 1054
                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 Element_subtype_definitionContext(ParserRuleContext):

        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, 120, self.RULE_element_subtype_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1055
            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 Record_constraintContext(ParserRuleContext):

        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 record_element_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Record_element_constraintContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Record_element_constraintContext,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_record_constraint

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

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

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




    def record_constraint(self):

        localctx = vhdlParser.Record_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_record_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1057
            self.match(vhdlParser.LPAREN)
            self.state = 1058
            self.record_element_constraint()
            self.state = 1063
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1059
                self.match(vhdlParser.COMMA)
                self.state = 1060
                self.record_element_constraint()
                self.state = 1065
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1066
            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 Record_element_constraintContext(ParserRuleContext):

        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 element_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Element_constraintContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_record_element_constraint

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

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

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




    def record_element_constraint(self):

        localctx = vhdlParser.Record_element_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_record_element_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1068
            self.identifier()
            self.state = 1069
            self.element_constraint()
        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):

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

        def KW_ACCESS(self):
            return self.getToken(vhdlParser.KW_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, 126, self.RULE_access_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1071
            self.match(vhdlParser.KW_ACCESS)
            self.state = 1072
            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 Incomplete_type_declarationContext(ParserRuleContext):

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

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

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


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

        def getRuleIndex(self):
            return vhdlParser.RULE_incomplete_type_declaration

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

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

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




    def incomplete_type_declaration(self):

        localctx = vhdlParser.Incomplete_type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_incomplete_type_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1074
            self.match(vhdlParser.KW_TYPE)
            self.state = 1075
            self.identifier()
            self.state = 1076
            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_type_definitionContext(ParserRuleContext):

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

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

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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,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, 130, self.RULE_file_type_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078
            self.match(vhdlParser.KW_FILE)
            self.state = 1079
            self.match(vhdlParser.KW_OF)
            self.state = 1080
            self.type_mark()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Protected_type_definitionContext(ParserRuleContext):

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

        def protected_type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Protected_type_declarationContext,0)


        def protected_type_body(self):
            return self.getTypedRuleContext(vhdlParser.Protected_type_bodyContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_protected_type_definition

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

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

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




    def protected_type_definition(self):

        localctx = vhdlParser.Protected_type_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_protected_type_definition)
        try:
            self.state = 1084
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1082
                self.protected_type_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1083
                self.protected_type_body()
                pass


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


    class Protected_type_declarationContext(ParserRuleContext):

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

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

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

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


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


        def getRuleIndex(self):
            return vhdlParser.RULE_protected_type_declaration

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

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

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




    def protected_type_declaration(self):

        localctx = vhdlParser.Protected_type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_protected_type_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1086
            self.match(vhdlParser.KW_PROTECTED)
            self.state = 1090
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 18)) & ~0x3f) == 0 and ((1 << (_la - 18)) & ((1 << (vhdlParser.KW_PURE - 18)) | (1 << (vhdlParser.KW_USE - 18)) | (1 << (vhdlParser.KW_PROCEDURE - 18)) | (1 << (vhdlParser.KW_ATTRIBUTE - 18)) | (1 << (vhdlParser.KW_FUNCTION - 18)) | (1 << (vhdlParser.KW_IMPURE - 18)))) != 0):
                self.state = 1087
                self.protected_type_declarative_item()
                self.state = 1092
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1093
            self.match(vhdlParser.KW_END)
            self.state = 1094
            self.match(vhdlParser.KW_PROTECTED)
            self.state = 1096
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1095
                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 Protected_type_declarative_itemContext(ParserRuleContext):

        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_instantiation_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_instantiation_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 getRuleIndex(self):
            return vhdlParser.RULE_protected_type_declarative_item

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

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

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




    def protected_type_declarative_item(self):

        localctx = vhdlParser.Protected_type_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_protected_type_declarative_item)
        try:
            self.state = 1102
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1098
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1099
                self.subprogram_instantiation_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1100
                self.attribute_specification()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1101
                self.use_clause()
                pass


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


    class Protected_type_bodyContext(ParserRuleContext):

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

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

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

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

        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 identifier(self):
            return self.getTypedRuleContext(vhdlParser.IdentifierContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_protected_type_body

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

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

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




    def protected_type_body(self):

        localctx = vhdlParser.Protected_type_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_protected_type_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1104
            self.match(vhdlParser.KW_PROTECTED)
            self.state = 1105
            self.match(vhdlParser.KW_BODY)
            self.state = 1109
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 1106
                self.process_declarative_item()
                self.state = 1111
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1112
            self.match(vhdlParser.KW_END)
            self.state = 1113
            self.match(vhdlParser.KW_PROTECTED)
            self.state = 1114
            self.match(vhdlParser.KW_BODY)
            self.state = 1116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1115
                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 Type_declarationContext(ParserRuleContext):

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

        def full_type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Full_type_declarationContext,0)


        def incomplete_type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Incomplete_type_declarationContext,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, 140, self.RULE_type_declaration)
        try:
            self.state = 1120
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1118
                self.full_type_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1119
                self.incomplete_type_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 Full_type_declarationContext(ParserRuleContext):

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

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

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


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

        def type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Type_definitionContext,0)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_full_type_declaration

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

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

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




    def full_type_declaration(self):

        localctx = vhdlParser.Full_type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_full_type_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1122
            self.match(vhdlParser.KW_TYPE)
            self.state = 1123
            self.identifier()
            self.state = 1124
            self.match(vhdlParser.KW_IS)
            self.state = 1125
            self.type_definition()
            self.state = 1126
            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):

        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 protected_type_definition(self):
            return self.getTypedRuleContext(vhdlParser.Protected_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, 144, self.RULE_type_definition)
        try:
            self.state = 1133
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_RANGE, vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1128
                self.scalar_type_definition()
                pass
            elif token in [vhdlParser.KW_RECORD, vhdlParser.KW_ARRAY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1129
                self.composite_type_definition()
                pass
            elif token in [vhdlParser.KW_ACCESS]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1130
                self.access_type_definition()
                pass
            elif token in [vhdlParser.KW_FILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1131
                self.file_type_definition()
                pass
            elif token in [vhdlParser.KW_PROTECTED]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1132
                self.protected_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 Subtype_declarationContext(ParserRuleContext):

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

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

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


        def KW_IS(self):
            return self.getToken(vhdlParser.KW_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, 146, self.RULE_subtype_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1135
            self.match(vhdlParser.KW_SUBTYPE)
            self.state = 1136
            self.identifier()
            self.state = 1137
            self.match(vhdlParser.KW_IS)
            self.state = 1138
            self.subtype_indication()
            self.state = 1139
            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):

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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,0)


        def resolution_indication(self):
            return self.getTypedRuleContext(vhdlParser.Resolution_indicationContext,0)


        def constraint(self):
            return self.getTypedRuleContext(vhdlParser.ConstraintContext,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, 148, self.RULE_subtype_indication)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1142
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 1141
                self.resolution_indication()


            self.state = 1144
            self.type_mark()
            self.state = 1146
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
            if la_ == 1:
                self.state = 1145
                self.constraint()


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


    class Resolution_indicationContext(ParserRuleContext):

        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 element_resolution(self):
            return self.getTypedRuleContext(vhdlParser.Element_resolutionContext,0)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_resolution_indication

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

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

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




    def resolution_indication(self):

        localctx = vhdlParser.Resolution_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_resolution_indication)
        try:
            self.state = 1153
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1148
                self.name(0)
                pass
            elif token in [vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1149
                self.match(vhdlParser.LPAREN)
                self.state = 1150
                self.element_resolution()
                self.state = 1151
                self.match(vhdlParser.RPAREN)
                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 Element_resolutionContext(ParserRuleContext):

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

        def array_element_resolution(self):
            return self.getTypedRuleContext(vhdlParser.Array_element_resolutionContext,0)


        def record_resolution(self):
            return self.getTypedRuleContext(vhdlParser.Record_resolutionContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_element_resolution

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

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

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




    def element_resolution(self):

        localctx = vhdlParser.Element_resolutionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_element_resolution)
        try:
            self.state = 1157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1155
                self.array_element_resolution()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1156
                self.record_resolution()
                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_element_resolutionContext(ParserRuleContext):

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

        def resolution_indication(self):
            return self.getTypedRuleContext(vhdlParser.Resolution_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_array_element_resolution

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

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

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




    def array_element_resolution(self):

        localctx = vhdlParser.Array_element_resolutionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_array_element_resolution)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1159
            self.resolution_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Record_resolutionContext(ParserRuleContext):

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

        def record_element_resolution(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Record_element_resolutionContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Record_element_resolutionContext,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_record_resolution

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

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

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




    def record_resolution(self):

        localctx = vhdlParser.Record_resolutionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_record_resolution)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1161
            self.record_element_resolution()
            self.state = 1166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1162
                self.match(vhdlParser.COMMA)
                self.state = 1163
                self.record_element_resolution()
                self.state = 1168
                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 Record_element_resolutionContext(ParserRuleContext):

        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 resolution_indication(self):
            return self.getTypedRuleContext(vhdlParser.Resolution_indicationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_record_element_resolution

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

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

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




    def record_element_resolution(self):

        localctx = vhdlParser.Record_element_resolutionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_record_element_resolution)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1169
            self.identifier()
            self.state = 1170
            self.resolution_indication()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_markContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_type_mark

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

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

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




    def type_mark(self):

        localctx = vhdlParser.Type_markContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_type_mark)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1172
            self.name(0)
        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):

        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 element_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Element_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, 162, self.RULE_constraint)
        try:
            self.state = 1176
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1174
                self.range_constraint()
                pass
            elif token in [vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1175
                self.element_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 Element_constraintContext(ParserRuleContext):

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

        def array_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Array_constraintContext,0)


        def record_constraint(self):
            return self.getTypedRuleContext(vhdlParser.Record_constraintContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_element_constraint

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

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

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




    def element_constraint(self):

        localctx = vhdlParser.Element_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_element_constraint)
        try:
            self.state = 1180
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1178
                self.array_constraint()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1179
                self.record_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 Object_declarationContext(ParserRuleContext):

        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 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, 166, self.RULE_object_declaration)
        try:
            self.state = 1186
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_CONSTANT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1182
                self.constant_declaration()
                pass
            elif token in [vhdlParser.KW_SIGNAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1183
                self.signal_declaration()
                pass
            elif token in [vhdlParser.KW_SHARED, vhdlParser.KW_VARIABLE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1184
                self.variable_declaration()
                pass
            elif token in [vhdlParser.KW_FILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1185
                self.file_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 Constant_declarationContext(ParserRuleContext):

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

        def KW_CONSTANT(self):
            return self.getToken(vhdlParser.KW_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, 168, self.RULE_constant_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1188
            self.match(vhdlParser.KW_CONSTANT)
            self.state = 1189
            self.identifier_list()
            self.state = 1190
            self.match(vhdlParser.COLON)
            self.state = 1191
            self.subtype_indication()
            self.state = 1194
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1192
                self.match(vhdlParser.VARASGN)
                self.state = 1193
                self.expression(0)


            self.state = 1196
            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):

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

        def KW_SIGNAL(self):
            return self.getToken(vhdlParser.KW_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, 170, self.RULE_signal_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1198
            self.match(vhdlParser.KW_SIGNAL)
            self.state = 1199
            self.identifier_list()
            self.state = 1200
            self.match(vhdlParser.COLON)
            self.state = 1201
            self.subtype_indication()
            self.state = 1203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_REGISTER or _la==vhdlParser.KW_BUS:
                self.state = 1202
                self.signal_kind()


            self.state = 1207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1205
                self.match(vhdlParser.VARASGN)
                self.state = 1206
                self.expression(0)


            self.state = 1209
            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):

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

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

        def KW_BUS(self):
            return self.getToken(vhdlParser.KW_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, 172, self.RULE_signal_kind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1211
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_REGISTER or _la==vhdlParser.KW_BUS):
                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 Variable_declarationContext(ParserRuleContext):

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

        def KW_VARIABLE(self):
            return self.getToken(vhdlParser.KW_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 KW_SHARED(self):
            return self.getToken(vhdlParser.KW_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, 174, self.RULE_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1214
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_SHARED:
                self.state = 1213
                self.match(vhdlParser.KW_SHARED)


            self.state = 1216
            self.match(vhdlParser.KW_VARIABLE)
            self.state = 1217
            self.identifier_list()
            self.state = 1218
            self.match(vhdlParser.COLON)
            self.state = 1219
            self.subtype_indication()
            self.state = 1222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1220
                self.match(vhdlParser.VARASGN)
                self.state = 1221
                self.expression(0)


            self.state = 1224
            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_declarationContext(ParserRuleContext):

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

        def KW_FILE(self):
            return self.getToken(vhdlParser.KW_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, 176, self.RULE_file_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1226
            self.match(vhdlParser.KW_FILE)
            self.state = 1227
            self.identifier_list()
            self.state = 1228
            self.match(vhdlParser.COLON)
            self.state = 1229
            self.subtype_indication()
            self.state = 1231
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IS or _la==vhdlParser.KW_OPEN:
                self.state = 1230
                self.file_open_information()


            self.state = 1233
            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_open_informationContext(ParserRuleContext):

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

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

        def file_logical_name(self):
            return self.getTypedRuleContext(vhdlParser.File_logical_nameContext,0)


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

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


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

        def KW_OUT(self):
            return self.getToken(vhdlParser.KW_OUT, 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, 178, self.RULE_file_open_information)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_OPEN:
                self.state = 1235
                self.match(vhdlParser.KW_OPEN)
                self.state = 1236
                self.expression(0)


            self.state = 1239
            self.match(vhdlParser.KW_IS)
            self.state = 1241
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT:
                self.state = 1240
                _la = self._input.LA(1)
                if not(_la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1243
            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_logical_nameContext(ParserRuleContext):

        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, 180, self.RULE_file_logical_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1245
            self.expression(0)
        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):

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

        def interface_object_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_object_declarationContext,0)


        def interface_type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_type_declarationContext,0)


        def interface_subprogram_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_subprogram_declarationContext,0)


        def interface_package_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_package_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, 182, self.RULE_interface_declaration)
        try:
            self.state = 1251
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_FILE, vhdlParser.KW_SIGNAL, vhdlParser.KW_VARIABLE, vhdlParser.KW_CONSTANT, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1247
                self.interface_object_declaration()
                pass
            elif token in [vhdlParser.KW_TYPE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1248
                self.interface_type_declaration()
                pass
            elif token in [vhdlParser.KW_PURE, vhdlParser.KW_PROCEDURE, vhdlParser.KW_FUNCTION, vhdlParser.KW_IMPURE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1249
                self.interface_subprogram_declaration()
                pass
            elif token in [vhdlParser.KW_PACKAGE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1250
                self.interface_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 Interface_object_declarationContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_interface_object_declaration

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

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

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




    def interface_object_declaration(self):

        localctx = vhdlParser.Interface_object_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_interface_object_declaration)
        try:
            self.state = 1257
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_CONSTANT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1253
                self.interface_constant_declaration()
                pass
            elif token in [vhdlParser.KW_SIGNAL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1254
                self.interface_signal_declaration()
                pass
            elif token in [vhdlParser.KW_VARIABLE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1255
                self.interface_variable_declaration()
                pass
            elif token in [vhdlParser.KW_FILE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1256
                self.interface_file_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 Interface_constant_declarationContext(ParserRuleContext):

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

        def KW_CONSTANT(self):
            return self.getToken(vhdlParser.KW_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 KW_IN(self):
            return self.getToken(vhdlParser.KW_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, 186, self.RULE_interface_constant_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1259
            self.match(vhdlParser.KW_CONSTANT)
            self.state = 1260
            self.identifier_list()
            self.state = 1261
            self.match(vhdlParser.COLON)
            self.state = 1263
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN:
                self.state = 1262
                self.match(vhdlParser.KW_IN)


            self.state = 1265
            self.subtype_indication()
            self.state = 1268
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1266
                self.match(vhdlParser.VARASGN)
                self.state = 1267
                self.expression(0)


        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):

        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 KW_SIGNAL(self):
            return self.getToken(vhdlParser.KW_SIGNAL, 0)

        def signal_mode(self):
            return self.getTypedRuleContext(vhdlParser.Signal_modeContext,0)


        def KW_BUS(self):
            return self.getToken(vhdlParser.KW_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, 188, self.RULE_interface_signal_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_SIGNAL:
                self.state = 1270
                self.match(vhdlParser.KW_SIGNAL)


            self.state = 1273
            self.identifier_list()
            self.state = 1274
            self.match(vhdlParser.COLON)
            self.state = 1276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_LINKAGE or _la==vhdlParser.KW_BUFFER or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.KW_IN - 68)) | (1 << (vhdlParser.KW_INOUT - 68)) | (1 << (vhdlParser.KW_OUT - 68)))) != 0):
                self.state = 1275
                self.signal_mode()


            self.state = 1278
            self.subtype_indication()
            self.state = 1280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_BUS:
                self.state = 1279
                self.match(vhdlParser.KW_BUS)


            self.state = 1284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1282
                self.match(vhdlParser.VARASGN)
                self.state = 1283
                self.expression(0)


        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):

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

        def KW_VARIABLE(self):
            return self.getToken(vhdlParser.KW_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 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, 190, self.RULE_interface_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1286
            self.match(vhdlParser.KW_VARIABLE)
            self.state = 1287
            self.identifier_list()
            self.state = 1288
            self.match(vhdlParser.COLON)
            self.state = 1290
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_LINKAGE or _la==vhdlParser.KW_BUFFER or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.KW_IN - 68)) | (1 << (vhdlParser.KW_INOUT - 68)) | (1 << (vhdlParser.KW_OUT - 68)))) != 0):
                self.state = 1289
                self.signal_mode()


            self.state = 1292
            self.subtype_indication()
            self.state = 1295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.VARASGN:
                self.state = 1293
                self.match(vhdlParser.VARASGN)
                self.state = 1294
                self.expression(0)


        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):

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

        def KW_FILE(self):
            return self.getToken(vhdlParser.KW_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, 192, self.RULE_interface_file_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1297
            self.match(vhdlParser.KW_FILE)
            self.state = 1298
            self.identifier_list()
            self.state = 1299
            self.match(vhdlParser.COLON)
            self.state = 1300
            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 Signal_modeContext(ParserRuleContext):

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

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

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

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

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

        def KW_LINKAGE(self):
            return self.getToken(vhdlParser.KW_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, 194, self.RULE_signal_mode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1302
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_LINKAGE or _la==vhdlParser.KW_BUFFER or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vhdlParser.KW_IN - 68)) | (1 << (vhdlParser.KW_INOUT - 68)) | (1 << (vhdlParser.KW_OUT - 68)))) != 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 Interface_type_declarationContext(ParserRuleContext):

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

        def interface_incomplete_type_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Interface_incomplete_type_declarationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_type_declaration

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

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

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




    def interface_type_declaration(self):

        localctx = vhdlParser.Interface_type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_interface_type_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1304
            self.interface_incomplete_type_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_incomplete_type_declarationContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_incomplete_type_declaration

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

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

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




    def interface_incomplete_type_declaration(self):

        localctx = vhdlParser.Interface_incomplete_type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_interface_incomplete_type_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1306
            self.match(vhdlParser.KW_TYPE)
            self.state = 1307
            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 Interface_subprogram_declarationContext(ParserRuleContext):

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

        def interface_subprogram_specification(self):
            return self.getTypedRuleContext(vhdlParser.Interface_subprogram_specificationContext,0)


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

        def interface_subprogram_default(self):
            return self.getTypedRuleContext(vhdlParser.Interface_subprogram_defaultContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_subprogram_declaration

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

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

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




    def interface_subprogram_declaration(self):

        localctx = vhdlParser.Interface_subprogram_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_interface_subprogram_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1309
            self.interface_subprogram_specification()
            self.state = 1312
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IS:
                self.state = 1310
                self.match(vhdlParser.KW_IS)
                self.state = 1311
                self.interface_subprogram_default()


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


    class Interface_subprogram_specificationContext(ParserRuleContext):

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

        def interface_procedure_specification(self):
            return self.getTypedRuleContext(vhdlParser.Interface_procedure_specificationContext,0)


        def interface_function_specification(self):
            return self.getTypedRuleContext(vhdlParser.Interface_function_specificationContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_subprogram_specification

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

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

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




    def interface_subprogram_specification(self):

        localctx = vhdlParser.Interface_subprogram_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_interface_subprogram_specification)
        try:
            self.state = 1316
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_PROCEDURE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1314
                self.interface_procedure_specification()
                pass
            elif token in [vhdlParser.KW_PURE, vhdlParser.KW_FUNCTION, vhdlParser.KW_IMPURE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1315
                self.interface_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 Interface_procedure_specificationContext(ParserRuleContext):

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

        def KW_PROCEDURE(self):
            return self.getToken(vhdlParser.KW_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 KW_PARAMETER(self):
            return self.getToken(vhdlParser.KW_PARAMETER, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_procedure_specification

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

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

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




    def interface_procedure_specification(self):

        localctx = vhdlParser.Interface_procedure_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_interface_procedure_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1318
            self.match(vhdlParser.KW_PROCEDURE)
            self.state = 1319
            self.designator()
            self.state = 1327
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PARAMETER or _la==vhdlParser.LPAREN:
                self.state = 1321
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_PARAMETER:
                    self.state = 1320
                    self.match(vhdlParser.KW_PARAMETER)


                self.state = 1323
                self.match(vhdlParser.LPAREN)
                self.state = 1324
                self.formal_parameter_list()
                self.state = 1325
                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 Interface_function_specificationContext(ParserRuleContext):

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

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

        def designator(self):
            return self.getTypedRuleContext(vhdlParser.DesignatorContext,0)


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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,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 KW_PURE(self):
            return self.getToken(vhdlParser.KW_PURE, 0)

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_function_specification

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

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

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




    def interface_function_specification(self):

        localctx = vhdlParser.Interface_function_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_interface_function_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1330
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PURE or _la==vhdlParser.KW_IMPURE:
                self.state = 1329
                _la = self._input.LA(1)
                if not(_la==vhdlParser.KW_PURE or _la==vhdlParser.KW_IMPURE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1332
            self.match(vhdlParser.KW_FUNCTION)
            self.state = 1333
            self.designator()
            self.state = 1341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PARAMETER or _la==vhdlParser.LPAREN:
                self.state = 1335
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_PARAMETER:
                    self.state = 1334
                    self.match(vhdlParser.KW_PARAMETER)


                self.state = 1337
                self.match(vhdlParser.LPAREN)
                self.state = 1338
                self.formal_parameter_list()
                self.state = 1339
                self.match(vhdlParser.RPAREN)


            self.state = 1343
            self.match(vhdlParser.KW_RETURN)
            self.state = 1344
            self.type_mark()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_subprogram_defaultContext(ParserRuleContext):

        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 BOX(self):
            return self.getToken(vhdlParser.BOX, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_subprogram_default

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

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

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




    def interface_subprogram_default(self):

        localctx = vhdlParser.Interface_subprogram_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_interface_subprogram_default)
        try:
            self.state = 1348
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1346
                self.name(0)
                pass
            elif token in [vhdlParser.BOX]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1347
                self.match(vhdlParser.BOX)
                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_package_declarationContext(ParserRuleContext):

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

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

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


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

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

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


        def interface_package_generic_map_aspect(self):
            return self.getTypedRuleContext(vhdlParser.Interface_package_generic_map_aspectContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_interface_package_declaration

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

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

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




    def interface_package_declaration(self):

        localctx = vhdlParser.Interface_package_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_interface_package_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1350
            self.match(vhdlParser.KW_PACKAGE)
            self.state = 1351
            self.identifier()
            self.state = 1352
            self.match(vhdlParser.KW_IS)
            self.state = 1353
            self.match(vhdlParser.KW_NEW)
            self.state = 1354
            self.name(0)
            self.state = 1355
            self.interface_package_generic_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 Interface_package_generic_map_aspectContext(ParserRuleContext):

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

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


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

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

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

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_interface_package_generic_map_aspect

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

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

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




    def interface_package_generic_map_aspect(self):

        localctx = vhdlParser.Interface_package_generic_map_aspectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_interface_package_generic_map_aspect)
        try:
            self.state = 1368
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1357
                self.generic_map_aspect()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1358
                self.match(vhdlParser.KW_GENERIC)
                self.state = 1359
                self.match(vhdlParser.KW_MAP)
                self.state = 1360
                self.match(vhdlParser.LPAREN)
                self.state = 1361
                self.match(vhdlParser.BOX)
                self.state = 1362
                self.match(vhdlParser.RPAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1363
                self.match(vhdlParser.KW_GENERIC)
                self.state = 1364
                self.match(vhdlParser.KW_MAP)
                self.state = 1365
                self.match(vhdlParser.LPAREN)
                self.state = 1366
                self.match(vhdlParser.KW_DEFAULT)
                self.state = 1367
                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 Interface_listContext(ParserRuleContext):

        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, 214, self.RULE_interface_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1370
            self.interface_element()
            self.state = 1375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.SEMI:
                self.state = 1371
                self.match(vhdlParser.SEMI)
                self.state = 1372
                self.interface_element()
                self.state = 1377
                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_elementContext(ParserRuleContext):

        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, 216, self.RULE_interface_element)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1378
            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 Generic_clauseContext(ParserRuleContext):

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

        def KW_GENERIC(self):
            return self.getToken(vhdlParser.KW_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, 218, self.RULE_generic_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1380
            self.match(vhdlParser.KW_GENERIC)
            self.state = 1381
            self.match(vhdlParser.LPAREN)
            self.state = 1382
            self.generic_list()
            self.state = 1383
            self.match(vhdlParser.RPAREN)
            self.state = 1384
            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):

        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_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, 220, self.RULE_generic_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1386
            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 Port_clauseContext(ParserRuleContext):

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

        def KW_PORT(self):
            return self.getToken(vhdlParser.KW_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, 222, self.RULE_port_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1388
            self.match(vhdlParser.KW_PORT)
            self.state = 1389
            self.match(vhdlParser.LPAREN)
            self.state = 1390
            self.port_list()
            self.state = 1391
            self.match(vhdlParser.RPAREN)
            self.state = 1392
            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):

        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_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, 224, self.RULE_port_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1394
            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 Association_listContext(ParserRuleContext):

        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 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 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_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, 226, self.RULE_association_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1396
            self.match(vhdlParser.LPAREN)
            self.state = 1397
            self.association_element()
            self.state = 1402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1398
                self.match(vhdlParser.COMMA)
                self.state = 1399
                self.association_element()
                self.state = 1404
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1405
            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 Association_elementContext(ParserRuleContext):

        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, 228, self.RULE_association_element)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1410
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.state = 1407
                self.formal_part()
                self.state = 1408
                self.match(vhdlParser.ARROW)


            self.state = 1412
            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 Formal_partContext(ParserRuleContext):

        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 LPAREN(self):
            return self.getToken(vhdlParser.LPAREN, 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, 230, self.RULE_formal_part)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1414
            self.name(0)
            self.state = 1419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 1415
                self.match(vhdlParser.LPAREN)
                self.state = 1416
                self.name(0)
                self.state = 1417
                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 Actual_partContext(ParserRuleContext):

        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, 232, self.RULE_actual_part)
        try:
            self.state = 1427
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1421
                self.name(0)
                self.state = 1422
                self.match(vhdlParser.LPAREN)
                self.state = 1423
                self.actual_designator()
                self.state = 1424
                self.match(vhdlParser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1426
                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 Actual_designatorContext(ParserRuleContext):

        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 KW_INERTIAL(self):
            return self.getToken(vhdlParser.KW_INERTIAL, 0)

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


        def KW_OPEN(self):
            return self.getToken(vhdlParser.KW_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, 234, self.RULE_actual_designator)
        self._la = 0 # Token type
        try:
            self.state = 1435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1430
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_INERTIAL:
                    self.state = 1429
                    self.match(vhdlParser.KW_INERTIAL)


                self.state = 1432
                self.expression(0)
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1434
                self.match(vhdlParser.KW_OPEN)
                pass


        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):

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

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

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

        def association_list(self):
            return self.getTypedRuleContext(vhdlParser.Association_listContext,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, 236, self.RULE_generic_map_aspect)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1437
            self.match(vhdlParser.KW_GENERIC)
            self.state = 1438
            self.match(vhdlParser.KW_MAP)
            self.state = 1439
            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 Port_map_aspectContext(ParserRuleContext):

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

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

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

        def association_list(self):
            return self.getTypedRuleContext(vhdlParser.Association_listContext,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, 238, self.RULE_port_map_aspect)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1441
            self.match(vhdlParser.KW_PORT)
            self.state = 1442
            self.match(vhdlParser.KW_MAP)
            self.state = 1443
            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 Alias_declarationContext(ParserRuleContext):

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

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

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


        def KW_IS(self):
            return self.getToken(vhdlParser.KW_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 subtype_indication(self):
            return self.getTypedRuleContext(vhdlParser.Subtype_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, 240, self.RULE_alias_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1445
            self.match(vhdlParser.KW_ALIAS)
            self.state = 1446
            self.alias_designator()
            self.state = 1449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.COLON:
                self.state = 1447
                self.match(vhdlParser.COLON)
                self.state = 1448
                self.subtype_indication()


            self.state = 1451
            self.match(vhdlParser.KW_IS)
            self.state = 1452
            self.name(0)
            self.state = 1454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LSQUARE_BR:
                self.state = 1453
                self.signature()


            self.state = 1456
            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):

        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 operator_symbol(self):
            return self.getTypedRuleContext(vhdlParser.Operator_symbolContext,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, 242, self.RULE_alias_designator)
        try:
            self.state = 1461
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1458
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1459
                self.match(vhdlParser.CHARACTER_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1460
                self.operator_symbol()
                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_declarationContext(ParserRuleContext):

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

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

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


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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,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, 244, self.RULE_attribute_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1463
            self.match(vhdlParser.KW_ATTRIBUTE)
            self.state = 1464
            self.identifier()
            self.state = 1465
            self.match(vhdlParser.COLON)
            self.state = 1466
            self.type_mark()
            self.state = 1467
            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):

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

        def KW_COMPONENT(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_COMPONENT)
            else:
                return self.getToken(vhdlParser.KW_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 KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

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

        def KW_IS(self):
            return self.getToken(vhdlParser.KW_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, 246, self.RULE_component_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1469
            self.match(vhdlParser.KW_COMPONENT)
            self.state = 1470
            self.identifier()
            self.state = 1472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IS:
                self.state = 1471
                self.match(vhdlParser.KW_IS)


            self.state = 1475
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 1474
                self.generic_clause()


            self.state = 1478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PORT:
                self.state = 1477
                self.port_clause()


            self.state = 1480
            self.match(vhdlParser.KW_END)
            self.state = 1481
            self.match(vhdlParser.KW_COMPONENT)
            self.state = 1483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 1482
                self.identifier()


            self.state = 1485
            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):

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

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

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


        def KW_IS(self):
            return self.getToken(vhdlParser.KW_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, 248, self.RULE_group_template_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1487
            self.match(vhdlParser.KW_GROUP)
            self.state = 1488
            self.identifier()
            self.state = 1489
            self.match(vhdlParser.KW_IS)
            self.state = 1490
            self.match(vhdlParser.LPAREN)
            self.state = 1491
            self.entity_class_entry_list()
            self.state = 1492
            self.match(vhdlParser.RPAREN)
            self.state = 1493
            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_class_entry_listContext(ParserRuleContext):

        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, 250, self.RULE_entity_class_entry_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1495
            self.entity_class_entry()
            self.state = 1500
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1496
                self.match(vhdlParser.COMMA)
                self.state = 1497
                self.entity_class_entry()
                self.state = 1502
                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_class_entryContext(ParserRuleContext):

        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, 252, self.RULE_entity_class_entry)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1503
            self.entity_class()
            self.state = 1505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BOX:
                self.state = 1504
                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 Group_declarationContext(ParserRuleContext):

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

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

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


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 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, 254, self.RULE_group_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1507
            self.match(vhdlParser.KW_GROUP)
            self.state = 1508
            self.identifier()
            self.state = 1509
            self.match(vhdlParser.COLON)
            self.state = 1510
            self.name(0)
            self.state = 1511
            self.match(vhdlParser.LPAREN)
            self.state = 1512
            self.group_constituent_list()
            self.state = 1513
            self.match(vhdlParser.RPAREN)
            self.state = 1514
            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_constituent_listContext(ParserRuleContext):

        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, 256, self.RULE_group_constituent_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1516
            self.group_constituent()
            self.state = 1521
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1517
                self.match(vhdlParser.COMMA)
                self.state = 1518
                self.group_constituent()
                self.state = 1523
                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_constituentContext(ParserRuleContext):

        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 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, 258, self.RULE_group_constituent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1524
            self.name(0)
        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):

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

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

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


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

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


        def KW_IS(self):
            return self.getToken(vhdlParser.KW_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, 260, self.RULE_attribute_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1526
            self.match(vhdlParser.KW_ATTRIBUTE)
            self.state = 1527
            self.attribute_designator()
            self.state = 1528
            self.match(vhdlParser.KW_OF)
            self.state = 1529
            self.entity_specification()
            self.state = 1530
            self.match(vhdlParser.KW_IS)
            self.state = 1531
            self.expression(0)
            self.state = 1532
            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_specificationContext(ParserRuleContext):

        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, 262, self.RULE_entity_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1534
            self.entity_name_list()
            self.state = 1535
            self.match(vhdlParser.COLON)
            self.state = 1536
            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_classContext(ParserRuleContext):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def KW_SEQUENCE(self):
            return self.getToken(vhdlParser.KW_SEQUENCE, 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, 264, self.RULE_entity_class)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1538
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_ENTITY) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_PROPERTY) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION) | (1 << vhdlParser.KW_LABEL))) != 0) or ((((_la - 82)) & ~0x3f) == 0 and ((1 << (_la - 82)) & ((1 << (vhdlParser.KW_PACKAGE - 82)) | (1 << (vhdlParser.KW_UNITS - 82)) | (1 << (vhdlParser.KW_LITERAL - 82)) | (1 << (vhdlParser.KW_SEQUENCE - 82)) | (1 << (vhdlParser.KW_TYPE - 82)) | (1 << (vhdlParser.KW_CONFIGURATION - 82)) | (1 << (vhdlParser.KW_ARCHITECTURE - 82)))) != 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_name_listContext(ParserRuleContext):

        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 KW_OTHERS(self):
            return self.getToken(vhdlParser.KW_OTHERS, 0)

        def KW_ALL(self):
            return self.getToken(vhdlParser.KW_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, 266, self.RULE_entity_name_list)
        self._la = 0 # Token type
        try:
            self.state = 1550
            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 = 1540
                self.entity_designator()
                self.state = 1545
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1541
                    self.match(vhdlParser.COMMA)
                    self.state = 1542
                    self.entity_designator()
                    self.state = 1547
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.KW_OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1548
                self.match(vhdlParser.KW_OTHERS)
                pass
            elif token in [vhdlParser.KW_ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1549
                self.match(vhdlParser.KW_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_designatorContext(ParserRuleContext):

        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, 268, self.RULE_entity_designator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1552
            self.entity_tag()
            self.state = 1554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LSQUARE_BR:
                self.state = 1553
                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_tagContext(ParserRuleContext):

        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 operator_symbol(self):
            return self.getTypedRuleContext(vhdlParser.Operator_symbolContext,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, 270, self.RULE_entity_tag)
        try:
            self.state = 1559
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1556
                self.identifier()
                pass
            elif token in [vhdlParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1557
                self.match(vhdlParser.CHARACTER_LITERAL)
                pass
            elif token in [vhdlParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1558
                self.operator_symbol()
                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_specificationContext(ParserRuleContext):

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

        def simple_configuration_specification(self):
            return self.getTypedRuleContext(vhdlParser.Simple_configuration_specificationContext,0)


        def compound_configuration_specification(self):
            return self.getTypedRuleContext(vhdlParser.Compound_configuration_specificationContext,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, 272, self.RULE_configuration_specification)
        try:
            self.state = 1563
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1561
                self.simple_configuration_specification()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1562
                self.compound_configuration_specification()
                pass


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


    class Simple_configuration_specificationContext(ParserRuleContext):

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

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

        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, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.SEMI)
            else:
                return self.getToken(vhdlParser.SEMI, i)

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

        def getRuleIndex(self):
            return vhdlParser.RULE_simple_configuration_specification

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

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

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




    def simple_configuration_specification(self):

        localctx = vhdlParser.Simple_configuration_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_simple_configuration_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            self.match(vhdlParser.KW_FOR)
            self.state = 1566
            self.component_specification()
            self.state = 1567
            self.binding_indication()
            self.state = 1568
            self.match(vhdlParser.SEMI)
            self.state = 1572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_END:
                self.state = 1569
                self.match(vhdlParser.KW_END)
                self.state = 1570
                self.match(vhdlParser.KW_FOR)
                self.state = 1571
                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 Compound_configuration_specificationContext(ParserRuleContext):

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

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

        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, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.SEMI)
            else:
                return self.getToken(vhdlParser.SEMI, i)

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

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


        def getRuleIndex(self):
            return vhdlParser.RULE_compound_configuration_specification

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

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

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




    def compound_configuration_specification(self):

        localctx = vhdlParser.Compound_configuration_specificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_compound_configuration_specification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1574
            self.match(vhdlParser.KW_FOR)
            self.state = 1575
            self.component_specification()
            self.state = 1576
            self.binding_indication()
            self.state = 1577
            self.match(vhdlParser.SEMI)
            self.state = 1581 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1578
                self.verification_unit_binding_indication()
                self.state = 1579
                self.match(vhdlParser.SEMI)
                self.state = 1583 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.KW_USE):
                    break

            self.state = 1585
            self.match(vhdlParser.KW_END)
            self.state = 1586
            self.match(vhdlParser.KW_FOR)
            self.state = 1587
            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):

        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, 278, self.RULE_component_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1589
            self.instantiation_list()
            self.state = 1590
            self.match(vhdlParser.COLON)
            self.state = 1591
            self.name(0)
        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):

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

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


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

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

        def KW_ALL(self):
            return self.getToken(vhdlParser.KW_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, 280, self.RULE_instantiation_list)
        self._la = 0 # Token type
        try:
            self.state = 1603
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1593
                self.label()
                self.state = 1598
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1594
                    self.match(vhdlParser.COMMA)
                    self.state = 1595
                    self.label()
                    self.state = 1600
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.KW_OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1601
                self.match(vhdlParser.KW_OTHERS)
                pass
            elif token in [vhdlParser.KW_ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1602
                self.match(vhdlParser.KW_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 Binding_indicationContext(ParserRuleContext):

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

        def KW_USE(self):
            return self.getToken(vhdlParser.KW_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, 282, self.RULE_binding_indication)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1607
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_USE:
                self.state = 1605
                self.match(vhdlParser.KW_USE)
                self.state = 1606
                self.entity_aspect()


            self.state = 1610
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 1609
                self.generic_map_aspect()


            self.state = 1613
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PORT:
                self.state = 1612
                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 Entity_aspectContext(ParserRuleContext):

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

        def KW_ENTITY(self):
            return self.getToken(vhdlParser.KW_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 KW_CONFIGURATION(self):
            return self.getToken(vhdlParser.KW_CONFIGURATION, 0)

        def KW_OPEN(self):
            return self.getToken(vhdlParser.KW_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, 284, self.RULE_entity_aspect)
        self._la = 0 # Token type
        try:
            self.state = 1626
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_ENTITY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1615
                self.match(vhdlParser.KW_ENTITY)
                self.state = 1616
                self.name(0)
                self.state = 1621
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.LPAREN:
                    self.state = 1617
                    self.match(vhdlParser.LPAREN)
                    self.state = 1618
                    self.identifier()
                    self.state = 1619
                    self.match(vhdlParser.RPAREN)


                pass
            elif token in [vhdlParser.KW_CONFIGURATION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1623
                self.match(vhdlParser.KW_CONFIGURATION)
                self.state = 1624
                self.name(0)
                pass
            elif token in [vhdlParser.KW_OPEN]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1625
                self.match(vhdlParser.KW_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 Verification_unit_binding_indicationContext(ParserRuleContext):

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

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

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

        def verification_unit_list(self):
            return self.getTypedRuleContext(vhdlParser.Verification_unit_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_verification_unit_binding_indication

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

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

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




    def verification_unit_binding_indication(self):

        localctx = vhdlParser.Verification_unit_binding_indicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_verification_unit_binding_indication)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1628
            self.match(vhdlParser.KW_USE)
            self.state = 1629
            self.match(vhdlParser.KW_VUNIT)
            self.state = 1630
            self.verification_unit_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Verification_unit_listContext(ParserRuleContext):

        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_verification_unit_list

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

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

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




    def verification_unit_list(self):

        localctx = vhdlParser.Verification_unit_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_verification_unit_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1632
            self.name(0)
            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.name(0)
                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 Disconnection_specificationContext(ParserRuleContext):

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

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

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


        def KW_AFTER(self):
            return self.getToken(vhdlParser.KW_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, 290, self.RULE_disconnection_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1640
            self.match(vhdlParser.KW_DISCONNECT)
            self.state = 1641
            self.guarded_signal_specification()
            self.state = 1642
            self.match(vhdlParser.KW_AFTER)
            self.state = 1643
            self.expression(0)
            self.state = 1644
            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):

        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 type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,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, 292, self.RULE_guarded_signal_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1646
            self.signal_list()
            self.state = 1647
            self.match(vhdlParser.COLON)
            self.state = 1648
            self.type_mark()
        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):

        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 KW_OTHERS(self):
            return self.getToken(vhdlParser.KW_OTHERS, 0)

        def KW_ALL(self):
            return self.getToken(vhdlParser.KW_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, 294, self.RULE_signal_list)
        self._la = 0 # Token type
        try:
            self.state = 1660
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1650
                self.name(0)
                self.state = 1655
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1651
                    self.match(vhdlParser.COMMA)
                    self.state = 1652
                    self.name(0)
                    self.state = 1657
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.KW_OTHERS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1658
                self.match(vhdlParser.KW_OTHERS)
                pass
            elif token in [vhdlParser.KW_ALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1659
                self.match(vhdlParser.KW_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 Attribute_designatorContext(ParserRuleContext):

        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 any_keyword(self):
            return self.getTypedRuleContext(vhdlParser.Any_keywordContext,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, 296, self.RULE_attribute_designator)
        try:
            self.state = 1664
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1662
                self.identifier()
                pass
            elif token in [vhdlParser.KW_PROCESS, vhdlParser.KW_CONTEXT, vhdlParser.KW_POSTPONED, vhdlParser.KW_LINKAGE, vhdlParser.KW_COMPONENT, vhdlParser.KW_ABS, vhdlParser.KW_DEFAULT, vhdlParser.KW_THEN, vhdlParser.KW_BLOCK, vhdlParser.KW_REM, vhdlParser.KW_INERTIAL, vhdlParser.KW_NEXT, vhdlParser.KW_ENTITY, vhdlParser.KW_ON, vhdlParser.KW_GROUP, vhdlParser.KW_XNOR, vhdlParser.KW_FILE, vhdlParser.KW_PURE, vhdlParser.KW_GUARDED, vhdlParser.KW_GENERIC, vhdlParser.KW_RANGE, vhdlParser.KW_ELSE, vhdlParser.KW_USE, vhdlParser.KW_SHARED, vhdlParser.KW_MOD, vhdlParser.KW_LOOP, vhdlParser.KW_RECORD, vhdlParser.KW_SIGNAL, vhdlParser.KW_REJECT, vhdlParser.KW_BEGIN, vhdlParser.KW_SLA, vhdlParser.KW_DISCONNECT, vhdlParser.KW_OF, vhdlParser.KW_PROCEDURE, vhdlParser.KW_SRL, vhdlParser.KW_VUNIT, vhdlParser.KW_ATTRIBUTE, vhdlParser.KW_VARIABLE, vhdlParser.KW_PROPERTY, vhdlParser.KW_UNAFFECTED, vhdlParser.KW_XOR, vhdlParser.KW_REGISTER, vhdlParser.KW_SUBTYPE, vhdlParser.KW_TO, vhdlParser.KW_NEW, vhdlParser.KW_REPORT, vhdlParser.KW_CONSTANT, vhdlParser.KW_BUFFER, vhdlParser.KW_BODY, vhdlParser.KW_AFTER, vhdlParser.KW_TRANSPORT, vhdlParser.KW_FUNCTION, vhdlParser.KW_END, vhdlParser.KW_SELECT, vhdlParser.KW_OR, vhdlParser.KW_LIBRARY, vhdlParser.KW_ELSIF, vhdlParser.KW_SLL, vhdlParser.KW_MAP, vhdlParser.KW_SRA, vhdlParser.KW_PROTECTED, vhdlParser.KW_DOWNTO, vhdlParser.KW_LABEL, vhdlParser.KW_ALL, vhdlParser.KW_ALIAS, vhdlParser.KW_GENERATE, vhdlParser.KW_NOR, vhdlParser.KW_IN, vhdlParser.KW_RELEASE, vhdlParser.KW_EXIT, vhdlParser.KW_RETURN, vhdlParser.KW_WITH, vhdlParser.KW_UNTIL, vhdlParser.KW_AND, vhdlParser.KW_INOUT, vhdlParser.KW_WAIT, vhdlParser.KW_NAND, vhdlParser.KW_ARRAY, vhdlParser.KW_FORCE, vhdlParser.KW_WHILE, vhdlParser.KW_IMPURE, vhdlParser.KW_PACKAGE, vhdlParser.KW_UNITS, vhdlParser.KW_ASSERT, vhdlParser.KW_PARAMETER, vhdlParser.KW_SEVERITY, vhdlParser.KW_LITERAL, vhdlParser.KW_FOR, vhdlParser.KW_ROR, vhdlParser.KW_IF, vhdlParser.KW_OUT, vhdlParser.KW_ROL, vhdlParser.KW_IS, vhdlParser.KW_SEQUENCE, vhdlParser.KW_OTHERS, vhdlParser.KW_TYPE, vhdlParser.KW_CASE, vhdlParser.KW_NOT, vhdlParser.KW_CONFIGURATION, vhdlParser.KW_OPEN, vhdlParser.KW_ARCHITECTURE, vhdlParser.KW_BUS, vhdlParser.KW_ACCESS, vhdlParser.KW_WHEN, vhdlParser.KW_PORT, vhdlParser.KW_NULL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1663
                self.any_keyword()
                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 External_nameContext(ParserRuleContext):

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

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

        def external_pathname(self):
            return self.getTypedRuleContext(vhdlParser.External_pathnameContext,0)


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

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


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

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_external_name

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

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

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




    def external_name(self):

        localctx = vhdlParser.External_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_external_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1666
            self.match(vhdlParser.SHIFT_LEFT)
            self.state = 1667
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_CONSTANT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1668
            self.external_pathname()
            self.state = 1669
            self.match(vhdlParser.COLON)
            self.state = 1670
            self.subtype_indication()
            self.state = 1671
            self.match(vhdlParser.SHIFT_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class External_pathnameContext(ParserRuleContext):

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

        def package_pathname(self):
            return self.getTypedRuleContext(vhdlParser.Package_pathnameContext,0)


        def absolute_pathname(self):
            return self.getTypedRuleContext(vhdlParser.Absolute_pathnameContext,0)


        def relative_pathname(self):
            return self.getTypedRuleContext(vhdlParser.Relative_pathnameContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_external_pathname

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

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

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




    def external_pathname(self):

        localctx = vhdlParser.External_pathnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_external_pathname)
        try:
            self.state = 1676
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1673
                self.package_pathname()
                pass
            elif token in [vhdlParser.DOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1674
                self.absolute_pathname()
                pass
            elif token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.UP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1675
                self.relative_pathname()
                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 Package_pathnameContext(ParserRuleContext):

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

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

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


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

        def getRuleIndex(self):
            return vhdlParser.RULE_package_pathname

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

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

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




    def package_pathname(self):

        localctx = vhdlParser.Package_pathnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_package_pathname)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1678
            self.match(vhdlParser.AT)
            self.state = 1679
            self.identifier()
            self.state = 1680
            self.match(vhdlParser.DOT)
            self.state = 1681
            self.identifier()
            self.state = 1682
            self.match(vhdlParser.DOT)
            self.state = 1683
            self.identifier()
            self.state = 1688
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.DOT:
                self.state = 1684
                self.match(vhdlParser.DOT)
                self.state = 1685
                self.identifier()
                self.state = 1690
                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 Absolute_pathnameContext(ParserRuleContext):

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

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

        def partial_pathname(self):
            return self.getTypedRuleContext(vhdlParser.Partial_pathnameContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_absolute_pathname

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

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

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




    def absolute_pathname(self):

        localctx = vhdlParser.Absolute_pathnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_absolute_pathname)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1691
            self.match(vhdlParser.DOT)
            self.state = 1692
            self.partial_pathname()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Relative_pathnameContext(ParserRuleContext):

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

        def partial_pathname(self):
            return self.getTypedRuleContext(vhdlParser.Partial_pathnameContext,0)


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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_relative_pathname

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

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

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




    def relative_pathname(self):

        localctx = vhdlParser.Relative_pathnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_relative_pathname)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1698
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.UP:
                self.state = 1694
                self.match(vhdlParser.UP)
                self.state = 1695
                self.match(vhdlParser.DOT)
                self.state = 1700
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Partial_pathnameContext(ParserRuleContext):

        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 pathname_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Pathname_elementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Pathname_elementContext,i)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_partial_pathname

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

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

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




    def partial_pathname(self):

        localctx = vhdlParser.Partial_pathnameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_partial_pathname)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1708
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,163,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1703
                    self.pathname_element()
                    self.state = 1704
                    self.match(vhdlParser.DOT) 
                self.state = 1710
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,163,self._ctx)

            self.state = 1711
            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 Pathname_elementContext(ParserRuleContext):

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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_pathname_element

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

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

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




    def pathname_element(self):

        localctx = vhdlParser.Pathname_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_pathname_element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1713
            self.label()
            self.state = 1718
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 1714
                self.match(vhdlParser.LPAREN)
                self.state = 1715
                self.expression(0)
                self.state = 1716
                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 ExpressionContext(ParserRuleContext):

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

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

        def primary(self):
            return self.getTypedRuleContext(vhdlParser.PrimaryContext,0)


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


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


        def shift_operator(self):
            return self.getTypedRuleContext(vhdlParser.Shift_operatorContext,0)


        def relational_operator(self):
            return self.getTypedRuleContext(vhdlParser.Relational_operatorContext,0)


        def logical_operator(self):
            return self.getTypedRuleContext(vhdlParser.Logical_operatorContext,0)


        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, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = vhdlParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 312
        self.enterRecursionRule(localctx, 312, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1724
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.COND_OP]:
                self.state = 1721
                self.match(vhdlParser.COND_OP)
                self.state = 1722
                self.primary()
                pass
            elif token in [vhdlParser.KW_ABS, vhdlParser.KW_XNOR, vhdlParser.KW_XOR, vhdlParser.KW_NEW, vhdlParser.KW_OR, vhdlParser.KW_NOR, vhdlParser.KW_AND, vhdlParser.KW_NAND, vhdlParser.KW_NOT, vhdlParser.KW_NULL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.DECIMAL_LITERAL, vhdlParser.BASED_LITERAL, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.SHIFT_LEFT, vhdlParser.PLUS, vhdlParser.MINUS]:
                self.state = 1723
                self.simple_expression(0)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1740
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,167,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1738
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                    if la_ == 1:
                        localctx = vhdlParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1726
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1727
                        self.shift_operator()
                        self.state = 1728
                        self.expression(4)
                        pass

                    elif la_ == 2:
                        localctx = vhdlParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1730
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1731
                        self.relational_operator()
                        self.state = 1732
                        self.expression(3)
                        pass

                    elif la_ == 3:
                        localctx = vhdlParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1734
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1735
                        self.logical_operator()
                        self.state = 1736
                        self.expression(2)
                        pass

             
                self.state = 1742
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,167,self._ctx)

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


    class Simple_expressionContext(ParserRuleContext):

        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 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 KW_ABS(self):
            return self.getToken(vhdlParser.KW_ABS, 0)

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

        def logical_operator(self):
            return self.getTypedRuleContext(vhdlParser.Logical_operatorContext,0)


        def sign(self):
            return self.getTypedRuleContext(vhdlParser.SignContext,0)


        def multiplying_operator(self):
            return self.getTypedRuleContext(vhdlParser.Multiplying_operatorContext,0)


        def adding_operator(self):
            return self.getTypedRuleContext(vhdlParser.Adding_operatorContext,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, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = vhdlParser.Simple_expressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 314
        self.enterRecursionRule(localctx, 314, self.RULE_simple_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1758
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_NEW, vhdlParser.KW_NULL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.DECIMAL_LITERAL, vhdlParser.BASED_LITERAL, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.SHIFT_LEFT]:
                self.state = 1744
                self.primary()
                self.state = 1747
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
                if la_ == 1:
                    self.state = 1745
                    self.match(vhdlParser.DOUBLESTAR)
                    self.state = 1746
                    self.primary()


                pass
            elif token in [vhdlParser.KW_ABS, vhdlParser.KW_XNOR, vhdlParser.KW_XOR, vhdlParser.KW_OR, vhdlParser.KW_NOR, vhdlParser.KW_AND, vhdlParser.KW_NAND, vhdlParser.KW_NOT]:
                self.state = 1752
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [vhdlParser.KW_ABS]:
                    self.state = 1749
                    self.match(vhdlParser.KW_ABS)
                    pass
                elif token in [vhdlParser.KW_NOT]:
                    self.state = 1750
                    self.match(vhdlParser.KW_NOT)
                    pass
                elif token in [vhdlParser.KW_XNOR, vhdlParser.KW_XOR, vhdlParser.KW_OR, vhdlParser.KW_NOR, vhdlParser.KW_AND, vhdlParser.KW_NAND]:
                    self.state = 1751
                    self.logical_operator()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1754
                self.simple_expression(4)
                pass
            elif token in [vhdlParser.PLUS, vhdlParser.MINUS]:
                self.state = 1755
                self.sign()
                self.state = 1756
                self.simple_expression(2)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1770
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,172,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1768
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                    if la_ == 1:
                        localctx = vhdlParser.Simple_expressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_simple_expression)
                        self.state = 1760
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1761
                        self.multiplying_operator()
                        self.state = 1762
                        self.simple_expression(4)
                        pass

                    elif la_ == 2:
                        localctx = vhdlParser.Simple_expressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_simple_expression)
                        self.state = 1764
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1765
                        self.adding_operator()
                        self.state = 1766
                        self.simple_expression(2)
                        pass

             
                self.state = 1772
                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.unrollRecursionContexts(_parentctx)
        return localctx


    class PrimaryContext(ParserRuleContext):

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

        def numeric_literal(self):
            return self.getTypedRuleContext(vhdlParser.Numeric_literalContext,0)


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

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

        def allocator(self):
            return self.getTypedRuleContext(vhdlParser.AllocatorContext,0)


        def aggregate(self):
            return self.getTypedRuleContext(vhdlParser.AggregateContext,0)


        def qualified_expression(self):
            return self.getTypedRuleContext(vhdlParser.Qualified_expressionContext,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, 316, self.RULE_primary)
        try:
            self.state = 1779
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1773
                self.numeric_literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1774
                self.match(vhdlParser.BIT_STRING_LITERAL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1775
                self.match(vhdlParser.KW_NULL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1776
                self.allocator()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1777
                self.aggregate()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1778
                self.qualified_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 Logical_operatorContext(ParserRuleContext):

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

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

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

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

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

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

        def KW_XNOR(self):
            return self.getToken(vhdlParser.KW_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, 318, self.RULE_logical_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1781
            _la = self._input.LA(1)
            if not(((((_la - 16)) & ~0x3f) == 0 and ((1 << (_la - 16)) & ((1 << (vhdlParser.KW_XNOR - 16)) | (1 << (vhdlParser.KW_XOR - 16)) | (1 << (vhdlParser.KW_OR - 16)) | (1 << (vhdlParser.KW_NOR - 16)) | (1 << (vhdlParser.KW_AND - 16)) | (1 << (vhdlParser.KW_NAND - 16)))) != 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 Relational_operatorContext(ParserRuleContext):

        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 NE(self):
            return self.getToken(vhdlParser.NE, 0)

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

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

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

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

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

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

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

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

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

        def GE_MATCH(self):
            return self.getToken(vhdlParser.GE_MATCH, 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, 320, self.RULE_relational_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1783
            _la = self._input.LA(1)
            if not(((((_la - 140)) & ~0x3f) == 0 and ((1 << (_la - 140)) & ((1 << (vhdlParser.EQ - 140)) | (1 << (vhdlParser.NE - 140)) | (1 << (vhdlParser.LT - 140)) | (1 << (vhdlParser.GT - 140)) | (1 << (vhdlParser.GE - 140)) | (1 << (vhdlParser.EQ_MATCH - 140)) | (1 << (vhdlParser.NE_MATCH - 140)) | (1 << (vhdlParser.LT_MATCH - 140)) | (1 << (vhdlParser.LE_MATCH - 140)) | (1 << (vhdlParser.GT_MATCH - 140)) | (1 << (vhdlParser.GE_MATCH - 140)) | (1 << (vhdlParser.CONASGN - 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 Shift_operatorContext(ParserRuleContext):

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

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

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

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

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

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

        def KW_ROR(self):
            return self.getToken(vhdlParser.KW_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, 322, self.RULE_shift_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1785
            _la = self._input.LA(1)
            if not(((((_la - 31)) & ~0x3f) == 0 and ((1 << (_la - 31)) & ((1 << (vhdlParser.KW_SLA - 31)) | (1 << (vhdlParser.KW_SRL - 31)) | (1 << (vhdlParser.KW_SLL - 31)) | (1 << (vhdlParser.KW_SRA - 31)) | (1 << (vhdlParser.KW_ROR - 31)) | (1 << (vhdlParser.KW_ROL - 31)))) != 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 Adding_operatorContext(ParserRuleContext):

        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, 324, self.RULE_adding_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1787
            _la = self._input.LA(1)
            if not(((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & ((1 << (vhdlParser.PLUS - 151)) | (1 << (vhdlParser.MINUS - 151)) | (1 << (vhdlParser.AMPERSAND - 151)))) != 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 SignContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_sign

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

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

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




    def sign(self):

        localctx = vhdlParser.SignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_sign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1789
            _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()
        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):

        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 KW_MOD(self):
            return self.getToken(vhdlParser.KW_MOD, 0)

        def KW_REM(self):
            return self.getToken(vhdlParser.KW_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, 328, self.RULE_multiplying_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1791
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_REM or _la==vhdlParser.KW_MOD 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 Miscellaneous_operatorContext(ParserRuleContext):

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

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_miscellaneous_operator

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

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

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




    def miscellaneous_operator(self):

        localctx = vhdlParser.Miscellaneous_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_miscellaneous_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1793
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_ABS or _la==vhdlParser.KW_NOT or _la==vhdlParser.DOUBLESTAR):
                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 Numeric_literalContext(ParserRuleContext):

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

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

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


        def BASED_LITERAL(self):
            return self.getToken(vhdlParser.BASED_LITERAL, 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, 332, self.RULE_numeric_literal)
        try:
            self.state = 1804
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.DECIMAL_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1795
                self.match(vhdlParser.DECIMAL_LITERAL)
                self.state = 1797
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                if la_ == 1:
                    self.state = 1796
                    self.name(0)


                pass
            elif token in [vhdlParser.BASED_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1799
                self.match(vhdlParser.BASED_LITERAL)
                self.state = 1801
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                if la_ == 1:
                    self.state = 1800
                    self.name(0)


                pass
            elif token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1803
                self.name(0)
                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 Physical_literalContext(ParserRuleContext):

        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 DECIMAL_LITERAL(self):
            return self.getToken(vhdlParser.DECIMAL_LITERAL, 0)

        def BASED_LITERAL(self):
            return self.getToken(vhdlParser.BASED_LITERAL, 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)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1807
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.DECIMAL_LITERAL or _la==vhdlParser.BASED_LITERAL:
                self.state = 1806
                _la = self._input.LA(1)
                if not(_la==vhdlParser.DECIMAL_LITERAL or _la==vhdlParser.BASED_LITERAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1809
            self.name(0)
        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):

        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, 336, self.RULE_aggregate)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1811
            self.match(vhdlParser.LPAREN)
            self.state = 1812
            self.element_association()
            self.state = 1817
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1813
                self.match(vhdlParser.COMMA)
                self.state = 1814
                self.element_association()
                self.state = 1819
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1820
            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 Element_associationContext(ParserRuleContext):

        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, 338, self.RULE_element_association)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1825
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.state = 1822
                self.choices()
                self.state = 1823
                self.match(vhdlParser.ARROW)


            self.state = 1827
            self.expression(0)
        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):

        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, 340, self.RULE_choices)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            self.choice()
            self.state = 1834
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.BAR:
                self.state = 1830
                self.match(vhdlParser.BAR)
                self.state = 1831
                self.choice()
                self.state = 1836
                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 ChoiceContext(ParserRuleContext):

        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 simple_expression(self):
            return self.getTypedRuleContext(vhdlParser.Simple_expressionContext,0)


        def KW_OTHERS(self):
            return self.getToken(vhdlParser.KW_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, 342, self.RULE_choice)
        try:
            self.state = 1840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1837
                self.discrete_range()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1838
                self.simple_expression(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1839
                self.match(vhdlParser.KW_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 Qualified_expressionContext(ParserRuleContext):

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

        def type_mark(self):
            return self.getTypedRuleContext(vhdlParser.Type_markContext,0)


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

        def aggregate(self):
            return self.getTypedRuleContext(vhdlParser.AggregateContext,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, 344, self.RULE_qualified_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1842
            self.type_mark()
            self.state = 1843
            self.match(vhdlParser.APOSTROPHE)
            self.state = 1844
            self.aggregate()
        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):

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

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

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


        def qualified_expression(self):
            return self.getTypedRuleContext(vhdlParser.Qualified_expressionContext,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, 346, self.RULE_allocator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1846
            self.match(vhdlParser.KW_NEW)
            self.state = 1849
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.state = 1847
                self.subtype_indication()
                pass

            elif la_ == 2:
                self.state = 1848
                self.qualified_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 Sequence_of_statementsContext(ParserRuleContext):

        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, 348, self.RULE_sequence_of_statements)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1854
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,183,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1851
                    self.sequential_statement() 
                self.state = 1856
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,183,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 Sequential_statementContext(ParserRuleContext):

        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 procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_call_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_statement(self):
            return self.getTypedRuleContext(vhdlParser.Null_statementContext,0)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 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, 350, self.RULE_sequential_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1860
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
            if la_ == 1:
                self.state = 1857
                self.label()
                self.state = 1858
                self.match(vhdlParser.COLON)


            self.state = 1875
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
            if la_ == 1:
                self.state = 1862
                self.wait_statement()
                pass

            elif la_ == 2:
                self.state = 1863
                self.assertion_statement()
                pass

            elif la_ == 3:
                self.state = 1864
                self.report_statement()
                pass

            elif la_ == 4:
                self.state = 1865
                self.signal_assignment_statement()
                pass

            elif la_ == 5:
                self.state = 1866
                self.variable_assignment_statement()
                pass

            elif la_ == 6:
                self.state = 1867
                self.procedure_call_statement()
                pass

            elif la_ == 7:
                self.state = 1868
                self.if_statement()
                pass

            elif la_ == 8:
                self.state = 1869
                self.case_statement()
                pass

            elif la_ == 9:
                self.state = 1870
                self.loop_statement()
                pass

            elif la_ == 10:
                self.state = 1871
                self.next_statement()
                pass

            elif la_ == 11:
                self.state = 1872
                self.exit_statement()
                pass

            elif la_ == 12:
                self.state = 1873
                self.return_statement()
                pass

            elif la_ == 13:
                self.state = 1874
                self.null_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 Wait_statementContext(ParserRuleContext):

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

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

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 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, 352, self.RULE_wait_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1877
            self.match(vhdlParser.KW_WAIT)
            self.state = 1879
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_ON:
                self.state = 1878
                self.sensitivity_clause()


            self.state = 1882
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_UNTIL:
                self.state = 1881
                self.condition_clause()


            self.state = 1885
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_FOR:
                self.state = 1884
                self.timeout_clause()


            self.state = 1887
            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 Sensitivity_clauseContext(ParserRuleContext):

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

        def KW_ON(self):
            return self.getToken(vhdlParser.KW_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, 354, self.RULE_sensitivity_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1889
            self.match(vhdlParser.KW_ON)
            self.state = 1890
            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):

        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, 356, self.RULE_sensitivity_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1892
            self.name(0)
            self.state = 1897
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 1893
                self.match(vhdlParser.COMMA)
                self.state = 1894
                self.name(0)
                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 Condition_clauseContext(ParserRuleContext):

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

        def KW_UNTIL(self):
            return self.getToken(vhdlParser.KW_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, 358, self.RULE_condition_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1900
            self.match(vhdlParser.KW_UNTIL)
            self.state = 1901
            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 ConditionContext(ParserRuleContext):

        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, 360, self.RULE_condition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1903
            self.expression(0)
        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):

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

        def KW_FOR(self):
            return self.getToken(vhdlParser.KW_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, 362, self.RULE_timeout_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1905
            self.match(vhdlParser.KW_FOR)
            self.state = 1906
            self.expression(0)
        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):

        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 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, 364, self.RULE_assertion_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1908
            self.assertion()
            self.state = 1909
            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 AssertionContext(ParserRuleContext):

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

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

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


        def KW_REPORT(self):
            return self.getToken(vhdlParser.KW_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 KW_SEVERITY(self):
            return self.getToken(vhdlParser.KW_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, 366, self.RULE_assertion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1911
            self.match(vhdlParser.KW_ASSERT)
            self.state = 1912
            self.condition()
            self.state = 1915
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_REPORT:
                self.state = 1913
                self.match(vhdlParser.KW_REPORT)
                self.state = 1914
                self.expression(0)


            self.state = 1919
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_SEVERITY:
                self.state = 1917
                self.match(vhdlParser.KW_SEVERITY)
                self.state = 1918
                self.expression(0)


        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):

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

        def KW_REPORT(self):
            return self.getToken(vhdlParser.KW_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 KW_SEVERITY(self):
            return self.getToken(vhdlParser.KW_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, 368, self.RULE_report_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1921
            self.match(vhdlParser.KW_REPORT)
            self.state = 1922
            self.expression(0)
            self.state = 1925
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_SEVERITY:
                self.state = 1923
                self.match(vhdlParser.KW_SEVERITY)
                self.state = 1924
                self.expression(0)


            self.state = 1927
            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_assignment_statementContext(ParserRuleContext):

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

        def simple_signal_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Simple_signal_assignmentContext,0)


        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 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, 370, self.RULE_signal_assignment_statement)
        try:
            self.state = 1932
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1929
                self.simple_signal_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1930
                self.conditional_signal_assignment()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1931
                self.selected_signal_assignment()
                pass


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


    class Simple_signal_assignmentContext(ParserRuleContext):

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

        def simple_waveform_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Simple_waveform_assignmentContext,0)


        def simple_force_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Simple_force_assignmentContext,0)


        def simple_release_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Simple_release_assignmentContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simple_signal_assignment

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

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

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




    def simple_signal_assignment(self):

        localctx = vhdlParser.Simple_signal_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_simple_signal_assignment)
        try:
            self.state = 1937
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1934
                self.simple_waveform_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1935
                self.simple_force_assignment()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1936
                self.simple_release_assignment()
                pass


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


    class Simple_waveform_assignmentContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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


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

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simple_waveform_assignment

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

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

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




    def simple_waveform_assignment(self):

        localctx = vhdlParser.Simple_waveform_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_simple_waveform_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1939
            self.target()
            self.state = 1940
            self.match(vhdlParser.CONASGN)
            self.state = 1942
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_TRANSPORT))) != 0):
                self.state = 1941
                self.delay_mechanism()


            self.state = 1944
            self.waveform()
            self.state = 1945
            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 Simple_force_assignmentContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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

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


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

        def force_mode(self):
            return self.getTypedRuleContext(vhdlParser.Force_modeContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simple_force_assignment

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

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

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




    def simple_force_assignment(self):

        localctx = vhdlParser.Simple_force_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_simple_force_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1947
            self.target()
            self.state = 1948
            self.match(vhdlParser.CONASGN)
            self.state = 1949
            self.match(vhdlParser.KW_FORCE)
            self.state = 1951
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT:
                self.state = 1950
                self.force_mode()


            self.state = 1953
            self.expression(0)
            self.state = 1954
            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 Simple_release_assignmentContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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

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

        def force_mode(self):
            return self.getTypedRuleContext(vhdlParser.Force_modeContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_simple_release_assignment

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

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

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




    def simple_release_assignment(self):

        localctx = vhdlParser.Simple_release_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_simple_release_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1956
            self.target()
            self.state = 1957
            self.match(vhdlParser.CONASGN)
            self.state = 1958
            self.match(vhdlParser.KW_RELEASE)
            self.state = 1960
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT:
                self.state = 1959
                self.force_mode()


            self.state = 1962
            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 Force_modeContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_force_mode

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

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

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




    def force_mode(self):

        localctx = vhdlParser.Force_modeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_force_mode)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1964
            _la = self._input.LA(1)
            if not(_la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT):
                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 Delay_mechanismContext(ParserRuleContext):

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

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

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

        def KW_REJECT(self):
            return self.getToken(vhdlParser.KW_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, 382, self.RULE_delay_mechanism)
        self._la = 0 # Token type
        try:
            self.state = 1972
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_TRANSPORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1966
                self.match(vhdlParser.KW_TRANSPORT)
                pass
            elif token in [vhdlParser.KW_INERTIAL, vhdlParser.KW_REJECT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1969
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_REJECT:
                    self.state = 1967
                    self.match(vhdlParser.KW_REJECT)
                    self.state = 1968
                    self.expression(0)


                self.state = 1971
                self.match(vhdlParser.KW_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 TargetContext(ParserRuleContext):

        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, 384, self.RULE_target)
        try:
            self.state = 1976
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1974
                self.name(0)
                pass
            elif token in [vhdlParser.LPAREN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1975
                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 WaveformContext(ParserRuleContext):

        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 KW_UNAFFECTED(self):
            return self.getToken(vhdlParser.KW_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, 386, self.RULE_waveform)
        self._la = 0 # Token type
        try:
            self.state = 1987
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_ABS, vhdlParser.KW_XNOR, vhdlParser.KW_XOR, vhdlParser.KW_NEW, vhdlParser.KW_OR, vhdlParser.KW_NOR, vhdlParser.KW_AND, vhdlParser.KW_NAND, vhdlParser.KW_NOT, vhdlParser.KW_NULL, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.DECIMAL_LITERAL, vhdlParser.BASED_LITERAL, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.BIT_STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.SHIFT_LEFT, vhdlParser.PLUS, vhdlParser.MINUS, vhdlParser.COND_OP]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1978
                self.waveform_element()
                self.state = 1983
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.COMMA:
                    self.state = 1979
                    self.match(vhdlParser.COMMA)
                    self.state = 1980
                    self.waveform_element()
                    self.state = 1985
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [vhdlParser.KW_UNAFFECTED]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1986
                self.match(vhdlParser.KW_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):

        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 KW_AFTER(self):
            return self.getToken(vhdlParser.KW_AFTER, 0)

        def KW_NULL(self):
            return self.getToken(vhdlParser.KW_NULL, 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, 388, self.RULE_waveform_element)
        self._la = 0 # Token type
        try:
            self.state = 1999
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1989
                self.expression(0)
                self.state = 1992
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_AFTER:
                    self.state = 1990
                    self.match(vhdlParser.KW_AFTER)
                    self.state = 1991
                    self.expression(0)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1994
                self.match(vhdlParser.KW_NULL)
                self.state = 1997
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_AFTER:
                    self.state = 1995
                    self.match(vhdlParser.KW_AFTER)
                    self.state = 1996
                    self.expression(0)


                pass


        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):

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

        def conditional_waveform_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_waveform_assignmentContext,0)


        def conditional_force_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_force_assignmentContext,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, 390, self.RULE_conditional_signal_assignment)
        try:
            self.state = 2003
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2001
                self.conditional_waveform_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2002
                self.conditional_force_assignment()
                pass


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


    class Conditional_waveform_assignmentContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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


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

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_waveform_assignment

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

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

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




    def conditional_waveform_assignment(self):

        localctx = vhdlParser.Conditional_waveform_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_conditional_waveform_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2005
            self.target()
            self.state = 2006
            self.match(vhdlParser.CONASGN)
            self.state = 2008
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_TRANSPORT))) != 0):
                self.state = 2007
                self.delay_mechanism()


            self.state = 2010
            self.conditional_waveforms()
            self.state = 2011
            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):

        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 KW_WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_WHEN)
            else:
                return self.getToken(vhdlParser.KW_WHEN, i)

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


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

        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, 394, self.RULE_conditional_waveforms)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2013
            self.waveform()
            self.state = 2014
            self.match(vhdlParser.KW_WHEN)
            self.state = 2015
            self.condition()
            self.state = 2023
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,208,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2016
                    self.match(vhdlParser.KW_ELSE)
                    self.state = 2017
                    self.waveform()
                    self.state = 2018
                    self.match(vhdlParser.KW_WHEN)
                    self.state = 2019
                    self.condition() 
                self.state = 2025
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,208,self._ctx)

            self.state = 2029
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 2026
                self.match(vhdlParser.KW_ELSE)
                self.state = 2027
                self.waveform()
                pass

            elif la_ == 2:
                self.state = 2028
                if not self._input.LA(1) != vhdlParser.KW_ELSE:

                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "_input->LA(1) != KW_ELSE")
                pass


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


    class Conditional_force_assignmentContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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

        def conditional_expressions(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_expressionsContext,0)


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

        def force_mode(self):
            return self.getTypedRuleContext(vhdlParser.Force_modeContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_force_assignment

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

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

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




    def conditional_force_assignment(self):

        localctx = vhdlParser.Conditional_force_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_conditional_force_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2031
            self.target()
            self.state = 2032
            self.match(vhdlParser.CONASGN)
            self.state = 2033
            self.match(vhdlParser.KW_FORCE)
            self.state = 2035
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT:
                self.state = 2034
                self.force_mode()


            self.state = 2037
            self.conditional_expressions()
            self.state = 2038
            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_expressionsContext(ParserRuleContext):

        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 KW_WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_WHEN)
            else:
                return self.getToken(vhdlParser.KW_WHEN, i)

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


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

        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_expressions

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

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

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




    def conditional_expressions(self):

        localctx = vhdlParser.Conditional_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_conditional_expressions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2040
            self.expression(0)
            self.state = 2041
            self.match(vhdlParser.KW_WHEN)
            self.state = 2042
            self.condition()
            self.state = 2050
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,211,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2043
                    self.match(vhdlParser.KW_ELSE)
                    self.state = 2044
                    self.expression(0)
                    self.state = 2045
                    self.match(vhdlParser.KW_WHEN)
                    self.state = 2046
                    self.condition() 
                self.state = 2052
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,211,self._ctx)

            self.state = 2056
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
            if la_ == 1:
                self.state = 2053
                self.match(vhdlParser.KW_ELSE)
                self.state = 2054
                self.expression(0)
                pass

            elif la_ == 2:
                self.state = 2055
                if not self._input.LA(1) != vhdlParser.KW_ELSE:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "_input->LA(1) != KW_ELSE")
                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_signal_assignmentContext(ParserRuleContext):

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

        def selected_waveform_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Selected_waveform_assignmentContext,0)


        def selected_force_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Selected_force_assignmentContext,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.state = 2060
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2058
                self.selected_waveform_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2059
                self.selected_force_assignment()
                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_waveform_assignmentContext(ParserRuleContext):

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

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

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


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

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


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

        def selected_waveforms(self):
            return self.getTypedRuleContext(vhdlParser.Selected_waveformsContext,0)


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

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

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_selected_waveform_assignment

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

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

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




    def selected_waveform_assignment(self):

        localctx = vhdlParser.Selected_waveform_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_selected_waveform_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2062
            self.match(vhdlParser.KW_WITH)
            self.state = 2063
            self.expression(0)
            self.state = 2064
            self.match(vhdlParser.KW_SELECT)
            self.state = 2066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2065
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2068
            self.target()
            self.state = 2069
            self.match(vhdlParser.CONASGN)
            self.state = 2071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_TRANSPORT))) != 0):
                self.state = 2070
                self.delay_mechanism()


            self.state = 2073
            self.selected_waveforms()
            self.state = 2074
            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):

        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 KW_WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_WHEN)
            else:
                return self.getToken(vhdlParser.KW_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, 404, self.RULE_selected_waveforms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2076
            self.waveform()
            self.state = 2077
            self.match(vhdlParser.KW_WHEN)
            self.state = 2078
            self.choices()
            self.state = 2086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2079
                self.match(vhdlParser.COMMA)
                self.state = 2080
                self.waveform()
                self.state = 2081
                self.match(vhdlParser.KW_WHEN)
                self.state = 2082
                self.choices()
                self.state = 2088
                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_force_assignmentContext(ParserRuleContext):

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

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

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


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

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


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

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

        def selected_expressions(self):
            return self.getTypedRuleContext(vhdlParser.Selected_expressionsContext,0)


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

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

        def force_mode(self):
            return self.getTypedRuleContext(vhdlParser.Force_modeContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_selected_force_assignment

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

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

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




    def selected_force_assignment(self):

        localctx = vhdlParser.Selected_force_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_selected_force_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2089
            self.match(vhdlParser.KW_WITH)
            self.state = 2090
            self.expression(0)
            self.state = 2091
            self.match(vhdlParser.KW_SELECT)
            self.state = 2093
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2092
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2095
            self.target()
            self.state = 2096
            self.match(vhdlParser.CONASGN)
            self.state = 2097
            self.match(vhdlParser.KW_FORCE)
            self.state = 2099
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IN or _la==vhdlParser.KW_OUT:
                self.state = 2098
                self.force_mode()


            self.state = 2101
            self.selected_expressions()
            self.state = 2102
            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_expressionsContext(ParserRuleContext):

        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 KW_WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_WHEN)
            else:
                return self.getToken(vhdlParser.KW_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_expressions

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

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

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




    def selected_expressions(self):

        localctx = vhdlParser.Selected_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_selected_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2104
            self.expression(0)
            self.state = 2105
            self.match(vhdlParser.KW_WHEN)
            self.state = 2106
            self.choices()
            self.state = 2114
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2107
                self.match(vhdlParser.COMMA)
                self.state = 2108
                self.expression(0)
                self.state = 2109
                self.match(vhdlParser.KW_WHEN)
                self.state = 2110
                self.choices()
                self.state = 2116
                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 Variable_assignment_statementContext(ParserRuleContext):

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

        def simple_variable_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Simple_variable_assignmentContext,0)


        def conditional_variable_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_variable_assignmentContext,0)


        def selected_variable_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Selected_variable_assignmentContext,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, 410, self.RULE_variable_assignment_statement)
        try:
            self.state = 2120
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,220,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2117
                self.simple_variable_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2118
                self.conditional_variable_assignment()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2119
                self.selected_variable_assignment()
                pass


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


    class Simple_variable_assignmentContext(ParserRuleContext):

        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 getRuleIndex(self):
            return vhdlParser.RULE_simple_variable_assignment

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

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

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




    def simple_variable_assignment(self):

        localctx = vhdlParser.Simple_variable_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 412, self.RULE_simple_variable_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2122
            self.target()
            self.state = 2123
            self.match(vhdlParser.VARASGN)
            self.state = 2124
            self.expression(0)
            self.state = 2125
            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_variable_assignmentContext(ParserRuleContext):

        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 conditional_expressions(self):
            return self.getTypedRuleContext(vhdlParser.Conditional_expressionsContext,0)


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

        def getRuleIndex(self):
            return vhdlParser.RULE_conditional_variable_assignment

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

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

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




    def conditional_variable_assignment(self):

        localctx = vhdlParser.Conditional_variable_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 414, self.RULE_conditional_variable_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2127
            self.target()
            self.state = 2128
            self.match(vhdlParser.VARASGN)
            self.state = 2129
            self.conditional_expressions()
            self.state = 2130
            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_variable_assignmentContext(ParserRuleContext):

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

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

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


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

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


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

        def selected_expressions(self):
            return self.getTypedRuleContext(vhdlParser.Selected_expressionsContext,0)


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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_selected_variable_assignment

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

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

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




    def selected_variable_assignment(self):

        localctx = vhdlParser.Selected_variable_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 416, self.RULE_selected_variable_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2132
            self.match(vhdlParser.KW_WITH)
            self.state = 2133
            self.expression(0)
            self.state = 2134
            self.match(vhdlParser.KW_SELECT)
            self.state = 2136
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2135
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2138
            self.target()
            self.state = 2139
            self.match(vhdlParser.VARASGN)
            self.state = 2140
            self.selected_expressions()
            self.state = 2141
            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 Procedure_call_statementContext(ParserRuleContext):

        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 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, 418, self.RULE_procedure_call_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2143
            self.procedure_call()
            self.state = 2144
            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 Procedure_callContext(ParserRuleContext):

        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 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, 420, self.RULE_procedure_call)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2146
            self.name(0)
        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):

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

        def KW_IF(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_IF)
            else:
                return self.getToken(vhdlParser.KW_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 KW_THEN(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_THEN)
            else:
                return self.getToken(vhdlParser.KW_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 KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

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

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

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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, 422, self.RULE_if_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2148
            self.match(vhdlParser.KW_IF)
            self.state = 2149
            self.condition()
            self.state = 2150
            self.match(vhdlParser.KW_THEN)
            self.state = 2151
            self.sequence_of_statements()
            self.state = 2159
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,222,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2152
                    self.match(vhdlParser.KW_ELSIF)
                    self.state = 2153
                    self.condition()
                    self.state = 2154
                    self.match(vhdlParser.KW_THEN)
                    self.state = 2155
                    self.sequence_of_statements() 
                self.state = 2161
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,222,self._ctx)

            self.state = 2166
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
            if la_ == 1:
                self.state = 2162
                self.match(vhdlParser.KW_ELSE)
                self.state = 2163
                self.sequence_of_statements()
                pass

            elif la_ == 2:
                pass

            elif la_ == 3:
                self.state = 2165
                if not self._input.LA(1) != vhdlParser.KW_ELSE:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "_input->LA(1) != KW_ELSE")
                pass


            self.state = 2168
            self.match(vhdlParser.KW_END)
            self.state = 2169
            self.match(vhdlParser.KW_IF)
            self.state = 2171
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2170
                self.label()


            self.state = 2173
            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):

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

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

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


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

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

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

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

        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 label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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, 424, self.RULE_case_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2175
            self.match(vhdlParser.KW_CASE)
            self.state = 2177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2176
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2179
            self.expression(0)
            self.state = 2180
            self.match(vhdlParser.KW_IS)
            self.state = 2182 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2181
                self.case_statement_alternative()
                self.state = 2184 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.KW_WHEN):
                    break

            self.state = 2186
            self.match(vhdlParser.KW_END)
            self.state = 2187
            self.match(vhdlParser.KW_CASE)
            self.state = 2189
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2188
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2192
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2191
                self.label()


            self.state = 2194
            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):

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

        def KW_WHEN(self):
            return self.getToken(vhdlParser.KW_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, 426, self.RULE_case_statement_alternative)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2196
            self.match(vhdlParser.KW_WHEN)
            self.state = 2197
            self.choices()
            self.state = 2198
            self.match(vhdlParser.ARROW)
            self.state = 2199
            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 Loop_statementContext(ParserRuleContext):

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

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

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


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

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

        def iteration_scheme(self):
            return self.getTypedRuleContext(vhdlParser.Iteration_schemeContext,0)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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, 428, self.RULE_loop_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2202
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_WHILE or _la==vhdlParser.KW_FOR:
                self.state = 2201
                self.iteration_scheme()


            self.state = 2204
            self.match(vhdlParser.KW_LOOP)
            self.state = 2205
            self.sequence_of_statements()
            self.state = 2206
            self.match(vhdlParser.KW_END)
            self.state = 2207
            self.match(vhdlParser.KW_LOOP)
            self.state = 2209
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2208
                self.label()


            self.state = 2211
            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 Iteration_schemeContext(ParserRuleContext):

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

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

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


        def KW_FOR(self):
            return self.getToken(vhdlParser.KW_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, 430, self.RULE_iteration_scheme)
        try:
            self.state = 2217
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_WHILE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2213
                self.match(vhdlParser.KW_WHILE)
                self.state = 2214
                self.condition()
                pass
            elif token in [vhdlParser.KW_FOR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2215
                self.match(vhdlParser.KW_FOR)
                self.state = 2216
                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 Parameter_specificationContext(ParserRuleContext):

        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 KW_IN(self):
            return self.getToken(vhdlParser.KW_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, 432, self.RULE_parameter_specification)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2219
            self.identifier()
            self.state = 2220
            self.match(vhdlParser.KW_IN)
            self.state = 2221
            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 Next_statementContext(ParserRuleContext):

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

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

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def KW_WHEN(self):
            return self.getToken(vhdlParser.KW_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, 434, self.RULE_next_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2223
            self.match(vhdlParser.KW_NEXT)
            self.state = 2225
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2224
                self.label()


            self.state = 2229
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_WHEN:
                self.state = 2227
                self.match(vhdlParser.KW_WHEN)
                self.state = 2228
                self.condition()


            self.state = 2231
            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 Exit_statementContext(ParserRuleContext):

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

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

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def KW_WHEN(self):
            return self.getToken(vhdlParser.KW_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, 436, self.RULE_exit_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2233
            self.match(vhdlParser.KW_EXIT)
            self.state = 2235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2234
                self.label()


            self.state = 2239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_WHEN:
                self.state = 2237
                self.match(vhdlParser.KW_WHEN)
                self.state = 2238
                self.condition()


            self.state = 2241
            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):

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

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

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 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, 438, self.RULE_return_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2243
            self.match(vhdlParser.KW_RETURN)
            self.state = 2245
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_ABS) | (1 << vhdlParser.KW_XNOR) | (1 << vhdlParser.KW_XOR) | (1 << vhdlParser.KW_NEW) | (1 << vhdlParser.KW_OR))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (vhdlParser.KW_NOR - 67)) | (1 << (vhdlParser.KW_AND - 67)) | (1 << (vhdlParser.KW_NAND - 67)) | (1 << (vhdlParser.KW_NOT - 67)) | (1 << (vhdlParser.KW_NULL - 67)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 67)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 67)) | (1 << (vhdlParser.DECIMAL_LITERAL - 67)) | (1 << (vhdlParser.BASED_LITERAL - 67)) | (1 << (vhdlParser.CHARACTER_LITERAL - 67)) | (1 << (vhdlParser.STRING_LITERAL - 67)) | (1 << (vhdlParser.BIT_STRING_LITERAL - 67)) | (1 << (vhdlParser.LPAREN - 67)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (vhdlParser.SHIFT_LEFT - 132)) | (1 << (vhdlParser.PLUS - 132)) | (1 << (vhdlParser.MINUS - 132)) | (1 << (vhdlParser.COND_OP - 132)))) != 0):
                self.state = 2244
                self.expression(0)


            self.state = 2247
            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 Null_statementContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return vhdlParser.RULE_null_statement

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

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

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




    def null_statement(self):

        localctx = vhdlParser.Null_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 440, self.RULE_null_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2249
            self.match(vhdlParser.KW_NULL)
            self.state = 2250
            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_statement_with_optional_labelContext(ParserRuleContext):

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

        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 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 getRuleIndex(self):
            return vhdlParser.RULE_concurrent_statement_with_optional_label

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

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

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




    def concurrent_statement_with_optional_label(self):

        localctx = vhdlParser.Concurrent_statement_with_optional_labelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 442, self.RULE_concurrent_statement_with_optional_label)
        try:
            self.state = 2256
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2252
                self.process_statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2253
                self.concurrent_procedure_call_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2254
                self.concurrent_assertion_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2255
                self.concurrent_signal_assignment_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 Concurrent_statementContext(ParserRuleContext):

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

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


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

        def block_statement(self):
            return self.getTypedRuleContext(vhdlParser.Block_statementContext,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_statement_with_optional_label(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_statement_with_optional_labelContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_statement

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

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

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




    def concurrent_statement(self):

        localctx = vhdlParser.Concurrent_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 444, self.RULE_concurrent_statement)
        try:
            self.state = 2267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,239,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2258
                self.label()
                self.state = 2259
                self.match(vhdlParser.COLON)
                self.state = 2264
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
                if la_ == 1:
                    self.state = 2260
                    self.block_statement()
                    pass

                elif la_ == 2:
                    self.state = 2261
                    self.component_instantiation_statement()
                    pass

                elif la_ == 3:
                    self.state = 2262
                    self.generate_statement()
                    pass

                elif la_ == 4:
                    self.state = 2263
                    self.concurrent_statement_with_optional_label()
                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2266
                self.concurrent_statement_with_optional_label()
                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):

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

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

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


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

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

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

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

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


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

        def KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 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 concurrent_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Concurrent_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Concurrent_statementContext,i)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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, 446, self.RULE_block_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2269
            self.match(vhdlParser.KW_BLOCK)
            self.state = 2274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 2270
                self.match(vhdlParser.LPAREN)
                self.state = 2271
                self.condition()
                self.state = 2272
                self.match(vhdlParser.RPAREN)


            self.state = 2277
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IS:
                self.state = 2276
                self.match(vhdlParser.KW_IS)


            self.state = 2279
            self.block_header()
            self.state = 2283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_FOR - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 2280
                self.block_declarative_item()
                self.state = 2285
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2286
            self.match(vhdlParser.KW_BEGIN)
            self.state = 2290
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.KW_PROCESS or _la==vhdlParser.KW_POSTPONED or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (vhdlParser.KW_WITH - 72)) | (1 << (vhdlParser.KW_ASSERT - 72)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 72)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 72)) | (1 << (vhdlParser.CHARACTER_LITERAL - 72)) | (1 << (vhdlParser.STRING_LITERAL - 72)) | (1 << (vhdlParser.LPAREN - 72)) | (1 << (vhdlParser.SHIFT_LEFT - 72)))) != 0):
                self.state = 2287
                self.concurrent_statement()
                self.state = 2292
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2293
            self.match(vhdlParser.KW_END)
            self.state = 2294
            self.match(vhdlParser.KW_BLOCK)
            self.state = 2296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2295
                self.label()


            self.state = 2298
            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_headerContext(ParserRuleContext):

        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, 448, self.RULE_block_header)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2306
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 2300
                self.generic_clause()
                self.state = 2304
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_GENERIC:
                    self.state = 2301
                    self.generic_map_aspect()
                    self.state = 2302
                    self.match(vhdlParser.SEMI)




            self.state = 2314
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PORT:
                self.state = 2308
                self.port_clause()
                self.state = 2312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_PORT:
                    self.state = 2309
                    self.port_map_aspect()
                    self.state = 2310
                    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_statementContext(ParserRuleContext):

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

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

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

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

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

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

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

        def process_sensitivity_list(self):
            return self.getTypedRuleContext(vhdlParser.Process_sensitivity_listContext,0)


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

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

        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 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 label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,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, 450, self.RULE_process_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2317
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_POSTPONED:
                self.state = 2316
                self.match(vhdlParser.KW_POSTPONED)


            self.state = 2319
            self.match(vhdlParser.KW_PROCESS)
            self.state = 2324
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.LPAREN:
                self.state = 2320
                self.match(vhdlParser.LPAREN)
                self.state = 2321
                self.process_sensitivity_list()
                self.state = 2322
                self.match(vhdlParser.RPAREN)


            self.state = 2327
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_IS:
                self.state = 2326
                self.match(vhdlParser.KW_IS)


            self.state = 2332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                self.state = 2329
                self.process_declarative_item()
                self.state = 2334
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2335
            self.match(vhdlParser.KW_BEGIN)
            self.state = 2339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_NEXT) | (1 << vhdlParser.KW_LOOP) | (1 << vhdlParser.KW_REPORT))) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (vhdlParser.KW_EXIT - 70)) | (1 << (vhdlParser.KW_RETURN - 70)) | (1 << (vhdlParser.KW_WITH - 70)) | (1 << (vhdlParser.KW_WAIT - 70)) | (1 << (vhdlParser.KW_WHILE - 70)) | (1 << (vhdlParser.KW_ASSERT - 70)) | (1 << (vhdlParser.KW_FOR - 70)) | (1 << (vhdlParser.KW_IF - 70)) | (1 << (vhdlParser.KW_CASE - 70)) | (1 << (vhdlParser.KW_NULL - 70)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 70)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 70)) | (1 << (vhdlParser.CHARACTER_LITERAL - 70)) | (1 << (vhdlParser.STRING_LITERAL - 70)) | (1 << (vhdlParser.LPAREN - 70)) | (1 << (vhdlParser.SHIFT_LEFT - 70)))) != 0):
                self.state = 2336
                self.sequential_statement()
                self.state = 2341
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2342
            self.match(vhdlParser.KW_END)
            self.state = 2344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_POSTPONED:
                self.state = 2343
                self.match(vhdlParser.KW_POSTPONED)


            self.state = 2346
            self.match(vhdlParser.KW_PROCESS)
            self.state = 2348
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2347
                self.label()


            self.state = 2350
            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_sensitivity_listContext(ParserRuleContext):

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

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

        def sensitivity_list(self):
            return self.getTypedRuleContext(vhdlParser.Sensitivity_listContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_process_sensitivity_list

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

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

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




    def process_sensitivity_list(self):

        localctx = vhdlParser.Process_sensitivity_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 452, self.RULE_process_sensitivity_list)
        try:
            self.state = 2354
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_ALL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2352
                self.match(vhdlParser.KW_ALL)
                pass
            elif token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2353
                self.sensitivity_list()
                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 Process_or_package_declarative_itemContext(ParserRuleContext):

        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_instantiation_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Subprogram_instantiation_declarationContext,0)


        def package_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Package_declarationContext,0)


        def package_instantiation_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Package_instantiation_declarationContext,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_or_package_declarative_item

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

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

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




    def process_or_package_declarative_item(self):

        localctx = vhdlParser.Process_or_package_declarative_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 454, self.RULE_process_or_package_declarative_item)
        try:
            self.state = 2371
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2356
                self.subprogram_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2357
                self.subprogram_instantiation_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2358
                self.package_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2359
                self.package_instantiation_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2360
                self.type_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2361
                self.subtype_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2362
                self.constant_declaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2363
                self.variable_declaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2364
                self.file_declaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2365
                self.alias_declaration()
                pass

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

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

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2368
                self.use_clause()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2369
                self.group_template_declaration()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 2370
                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_itemContext(ParserRuleContext):

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

        def process_or_package_declarative_item(self):
            return self.getTypedRuleContext(vhdlParser.Process_or_package_declarative_itemContext,0)


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


        def package_body(self):
            return self.getTypedRuleContext(vhdlParser.Package_bodyContext,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, 456, self.RULE_process_declarative_item)
        try:
            self.state = 2376
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2373
                self.process_or_package_declarative_item()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2375
                self.package_body()
                pass


        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):

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

        def procedure_call_statement(self):
            return self.getTypedRuleContext(vhdlParser.Procedure_call_statementContext,0)


        def KW_POSTPONED(self):
            return self.getToken(vhdlParser.KW_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, 458, self.RULE_concurrent_procedure_call_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2379
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_POSTPONED:
                self.state = 2378
                self.match(vhdlParser.KW_POSTPONED)


            self.state = 2381
            self.procedure_call_statement()
        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):

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

        def assertion_statement(self):
            return self.getTypedRuleContext(vhdlParser.Assertion_statementContext,0)


        def KW_POSTPONED(self):
            return self.getToken(vhdlParser.KW_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, 460, self.RULE_concurrent_assertion_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2384
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_POSTPONED:
                self.state = 2383
                self.match(vhdlParser.KW_POSTPONED)


            self.state = 2386
            self.assertion_statement()
        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):

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

        def concurrent_signal_assignment_any(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_signal_assignment_anyContext,0)


        def concurrent_selected_signal_assignment(self):
            return self.getTypedRuleContext(vhdlParser.Concurrent_selected_signal_assignmentContext,0)


        def KW_POSTPONED(self):
            return self.getToken(vhdlParser.KW_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, 462, self.RULE_concurrent_signal_assignment_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2389
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_POSTPONED:
                self.state = 2388
                self.match(vhdlParser.KW_POSTPONED)


            self.state = 2393
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.SHIFT_LEFT]:
                self.state = 2391
                self.concurrent_signal_assignment_any()
                pass
            elif token in [vhdlParser.KW_WITH]:
                self.state = 2392
                self.concurrent_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 Concurrent_signal_assignment_anyContext(ParserRuleContext):

        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 CONASGN(self):
            return self.getToken(vhdlParser.CONASGN, 0)

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

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


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


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

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_signal_assignment_any

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

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

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




    def concurrent_signal_assignment_any(self):

        localctx = vhdlParser.Concurrent_signal_assignment_anyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 464, self.RULE_concurrent_signal_assignment_any)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2395
            self.target()
            self.state = 2396
            self.match(vhdlParser.CONASGN)
            self.state = 2398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GUARDED:
                self.state = 2397
                self.match(vhdlParser.KW_GUARDED)


            self.state = 2401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_TRANSPORT))) != 0):
                self.state = 2400
                self.delay_mechanism()


            self.state = 2405
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
            if la_ == 1:
                self.state = 2403
                self.waveform()
                pass

            elif la_ == 2:
                self.state = 2404
                self.conditional_waveforms()
                pass


            self.state = 2407
            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_selected_signal_assignmentContext(ParserRuleContext):

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

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

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


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

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


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

        def selected_waveforms(self):
            return self.getTypedRuleContext(vhdlParser.Selected_waveformsContext,0)


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

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

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

        def delay_mechanism(self):
            return self.getTypedRuleContext(vhdlParser.Delay_mechanismContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_concurrent_selected_signal_assignment

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

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

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




    def concurrent_selected_signal_assignment(self):

        localctx = vhdlParser.Concurrent_selected_signal_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 466, self.RULE_concurrent_selected_signal_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2409
            self.match(vhdlParser.KW_WITH)
            self.state = 2410
            self.expression(0)
            self.state = 2411
            self.match(vhdlParser.KW_SELECT)
            self.state = 2413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.QUESTIONMARK:
                self.state = 2412
                self.match(vhdlParser.QUESTIONMARK)


            self.state = 2415
            self.target()
            self.state = 2416
            self.match(vhdlParser.CONASGN)
            self.state = 2418
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GUARDED:
                self.state = 2417
                self.match(vhdlParser.KW_GUARDED)


            self.state = 2421
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_INERTIAL) | (1 << vhdlParser.KW_REJECT) | (1 << vhdlParser.KW_TRANSPORT))) != 0):
                self.state = 2420
                self.delay_mechanism()


            self.state = 2423
            self.selected_waveforms()
            self.state = 2424
            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):

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

        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, 468, self.RULE_component_instantiation_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2426
            self.instantiated_unit()
            self.state = 2428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_GENERIC:
                self.state = 2427
                self.generic_map_aspect()


            self.state = 2431
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_PORT:
                self.state = 2430
                self.port_map_aspect()


            self.state = 2433
            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 Instantiated_unitContext(ParserRuleContext):

        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 KW_COMPONENT(self):
            return self.getToken(vhdlParser.KW_COMPONENT, 0)

        def KW_ENTITY(self):
            return self.getToken(vhdlParser.KW_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 KW_CONFIGURATION(self):
            return self.getToken(vhdlParser.KW_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, 470, self.RULE_instantiated_unit)
        self._la = 0 # Token type
        try:
            self.state = 2449
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_COMPONENT, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2436
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.KW_COMPONENT:
                    self.state = 2435
                    self.match(vhdlParser.KW_COMPONENT)


                self.state = 2438
                self.name(0)
                pass
            elif token in [vhdlParser.KW_ENTITY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2439
                self.match(vhdlParser.KW_ENTITY)
                self.state = 2440
                self.name(0)
                self.state = 2445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.LPAREN:
                    self.state = 2441
                    self.match(vhdlParser.LPAREN)
                    self.state = 2442
                    self.identifier()
                    self.state = 2443
                    self.match(vhdlParser.RPAREN)


                pass
            elif token in [vhdlParser.KW_CONFIGURATION]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2447
                self.match(vhdlParser.KW_CONFIGURATION)
                self.state = 2448
                self.name(0)
                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 Generate_statementContext(ParserRuleContext):

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

        def for_generate_statement(self):
            return self.getTypedRuleContext(vhdlParser.For_generate_statementContext,0)


        def if_generate_statement(self):
            return self.getTypedRuleContext(vhdlParser.If_generate_statementContext,0)


        def case_generate_statement(self):
            return self.getTypedRuleContext(vhdlParser.Case_generate_statementContext,0)


        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, 472, self.RULE_generate_statement)
        try:
            self.state = 2454
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_FOR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2451
                self.for_generate_statement()
                pass
            elif token in [vhdlParser.KW_IF]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2452
                self.if_generate_statement()
                pass
            elif token in [vhdlParser.KW_CASE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2453
                self.case_generate_statement()
                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 For_generate_statementContext(ParserRuleContext):

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

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

        def parameter_specification(self):
            return self.getTypedRuleContext(vhdlParser.Parameter_specificationContext,0)


        def KW_GENERATE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_GENERATE)
            else:
                return self.getToken(vhdlParser.KW_GENERATE, i)

        def generate_statement_body(self):
            return self.getTypedRuleContext(vhdlParser.Generate_statement_bodyContext,0)


        def KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_for_generate_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFor_generate_statement" ):
                listener.enterFor_generate_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFor_generate_statement" ):
                listener.exitFor_generate_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFor_generate_statement" ):
                return visitor.visitFor_generate_statement(self)
            else:
                return visitor.visitChildren(self)




    def for_generate_statement(self):

        localctx = vhdlParser.For_generate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 474, self.RULE_for_generate_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2456
            self.match(vhdlParser.KW_FOR)
            self.state = 2457
            self.parameter_specification()
            self.state = 2458
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2459
            self.generate_statement_body()
            self.state = 2460
            self.match(vhdlParser.KW_END)
            self.state = 2461
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2462
                self.label()


            self.state = 2465
            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 If_generate_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_IF(self):
            return self.getToken(vhdlParser.KW_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 KW_GENERATE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_GENERATE)
            else:
                return self.getToken(vhdlParser.KW_GENERATE, i)

        def generate_statement_body(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Generate_statement_bodyContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Generate_statement_bodyContext,i)


        def KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def KW_ELSE(self):
            return self.getToken(vhdlParser.KW_ELSE, 0)

        def label(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.LabelContext)
            else:
                return self.getTypedRuleContext(vhdlParser.LabelContext,i)


        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.COLON)
            else:
                return self.getToken(vhdlParser.COLON, i)

        def KW_ELSIF(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_ELSIF)
            else:
                return self.getToken(vhdlParser.KW_ELSIF, i)

        def getRuleIndex(self):
            return vhdlParser.RULE_if_generate_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIf_generate_statement" ):
                listener.enterIf_generate_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIf_generate_statement" ):
                listener.exitIf_generate_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIf_generate_statement" ):
                return visitor.visitIf_generate_statement(self)
            else:
                return visitor.visitChildren(self)




    def if_generate_statement(self):

        localctx = vhdlParser.If_generate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 476, self.RULE_if_generate_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2467
            self.match(vhdlParser.KW_IF)
            self.state = 2471
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
            if la_ == 1:
                self.state = 2468
                self.label()
                self.state = 2469
                self.match(vhdlParser.COLON)


            self.state = 2473
            self.condition()
            self.state = 2474
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2475
            self.generate_statement_body()
            self.state = 2488
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,278,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2476
                    self.match(vhdlParser.KW_ELSIF)
                    self.state = 2480
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
                    if la_ == 1:
                        self.state = 2477
                        self.label()
                        self.state = 2478
                        self.match(vhdlParser.COLON)


                    self.state = 2482
                    self.condition()
                    self.state = 2483
                    self.match(vhdlParser.KW_GENERATE)
                    self.state = 2484
                    self.generate_statement_body() 
                self.state = 2490
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,278,self._ctx)

            self.state = 2500
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,280,self._ctx)
            if la_ == 1:
                self.state = 2491
                self.match(vhdlParser.KW_ELSE)
                self.state = 2495
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                    self.state = 2492
                    self.label()
                    self.state = 2493
                    self.match(vhdlParser.COLON)


                self.state = 2497
                self.match(vhdlParser.KW_GENERATE)
                self.state = 2498
                self.generate_statement_body()
                pass

            elif la_ == 2:
                self.state = 2499
                if not self._input.LA(1) != vhdlParser.KW_ELSE:
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "_input->LA(1) != KW_ELSE")
                pass


            self.state = 2502
            self.match(vhdlParser.KW_END)
            self.state = 2503
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2504
                self.label()


            self.state = 2507
            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_generate_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_CASE(self):
            return self.getToken(vhdlParser.KW_CASE, 0)

        def expression(self):
            return self.getTypedRuleContext(vhdlParser.ExpressionContext,0)


        def KW_GENERATE(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_GENERATE)
            else:
                return self.getToken(vhdlParser.KW_GENERATE, i)

        def KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def case_generate_alternative(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Case_generate_alternativeContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Case_generate_alternativeContext,i)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_case_generate_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCase_generate_statement" ):
                listener.enterCase_generate_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCase_generate_statement" ):
                listener.exitCase_generate_statement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCase_generate_statement" ):
                return visitor.visitCase_generate_statement(self)
            else:
                return visitor.visitChildren(self)




    def case_generate_statement(self):

        localctx = vhdlParser.Case_generate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 478, self.RULE_case_generate_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2509
            self.match(vhdlParser.KW_CASE)
            self.state = 2510
            self.expression(0)
            self.state = 2511
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2513 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2512
                self.case_generate_alternative()
                self.state = 2515 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vhdlParser.KW_WHEN):
                    break

            self.state = 2517
            self.match(vhdlParser.KW_END)
            self.state = 2518
            self.match(vhdlParser.KW_GENERATE)
            self.state = 2520
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2519
                self.label()


            self.state = 2522
            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_generate_alternativeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_WHEN(self):
            return self.getToken(vhdlParser.KW_WHEN, 0)

        def choices(self):
            return self.getTypedRuleContext(vhdlParser.ChoicesContext,0)


        def ARROW(self):
            return self.getToken(vhdlParser.ARROW, 0)

        def generate_statement_body_with_begin_end(self):
            return self.getTypedRuleContext(vhdlParser.Generate_statement_body_with_begin_endContext,0)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def COLON(self):
            return self.getToken(vhdlParser.COLON, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_case_generate_alternative

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCase_generate_alternative" ):
                listener.enterCase_generate_alternative(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCase_generate_alternative" ):
                listener.exitCase_generate_alternative(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCase_generate_alternative" ):
                return visitor.visitCase_generate_alternative(self)
            else:
                return visitor.visitChildren(self)




    def case_generate_alternative(self):

        localctx = vhdlParser.Case_generate_alternativeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 480, self.RULE_case_generate_alternative)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2524
            self.match(vhdlParser.KW_WHEN)
            self.state = 2528
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,284,self._ctx)
            if la_ == 1:
                self.state = 2525
                self.label()
                self.state = 2526
                self.match(vhdlParser.COLON)


            self.state = 2530
            self.choices()
            self.state = 2531
            self.match(vhdlParser.ARROW)
            self.state = 2532
            self.generate_statement_body_with_begin_end()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Generate_statement_body_with_begin_endContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_BEGIN(self):
            return self.getToken(vhdlParser.KW_BEGIN, 0)

        def KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 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 concurrent_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Concurrent_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Concurrent_statementContext,i)


        def label(self):
            return self.getTypedRuleContext(vhdlParser.LabelContext,0)


        def getRuleIndex(self):
            return vhdlParser.RULE_generate_statement_body_with_begin_end

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGenerate_statement_body_with_begin_end" ):
                listener.enterGenerate_statement_body_with_begin_end(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGenerate_statement_body_with_begin_end" ):
                listener.exitGenerate_statement_body_with_begin_end(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGenerate_statement_body_with_begin_end" ):
                return visitor.visitGenerate_statement_body_with_begin_end(self)
            else:
                return visitor.visitChildren(self)




    def generate_statement_body_with_begin_end(self):

        localctx = vhdlParser.Generate_statement_body_with_begin_endContext(self, self._ctx, self.state)
        self.enterRule(localctx, 482, self.RULE_generate_statement_body_with_begin_end)
        self._la = 0 # Token type
        try:
            self.state = 2558
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_COMPONENT, vhdlParser.KW_GROUP, vhdlParser.KW_FILE, vhdlParser.KW_PURE, vhdlParser.KW_USE, vhdlParser.KW_SHARED, vhdlParser.KW_SIGNAL, vhdlParser.KW_BEGIN, vhdlParser.KW_DISCONNECT, vhdlParser.KW_PROCEDURE, vhdlParser.KW_ATTRIBUTE, vhdlParser.KW_VARIABLE, vhdlParser.KW_SUBTYPE, vhdlParser.KW_CONSTANT, vhdlParser.KW_FUNCTION, vhdlParser.KW_ALIAS, vhdlParser.KW_IMPURE, vhdlParser.KW_PACKAGE, vhdlParser.KW_FOR, vhdlParser.KW_TYPE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2537
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_FOR - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                    self.state = 2534
                    self.block_declarative_item()
                    self.state = 2539
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2540
                self.match(vhdlParser.KW_BEGIN)
                self.state = 2544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.KW_PROCESS or _la==vhdlParser.KW_POSTPONED or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (vhdlParser.KW_WITH - 72)) | (1 << (vhdlParser.KW_ASSERT - 72)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 72)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 72)) | (1 << (vhdlParser.CHARACTER_LITERAL - 72)) | (1 << (vhdlParser.STRING_LITERAL - 72)) | (1 << (vhdlParser.LPAREN - 72)) | (1 << (vhdlParser.SHIFT_LEFT - 72)))) != 0):
                    self.state = 2541
                    self.concurrent_statement()
                    self.state = 2546
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2547
                self.match(vhdlParser.KW_END)
                self.state = 2549
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                    self.state = 2548
                    self.label()


                self.state = 2551
                self.match(vhdlParser.SEMI)
                pass
            elif token in [vhdlParser.KW_PROCESS, vhdlParser.KW_POSTPONED, vhdlParser.KW_END, vhdlParser.KW_WITH, vhdlParser.KW_ASSERT, vhdlParser.KW_WHEN, vhdlParser.BASIC_IDENTIFIER, vhdlParser.EXTENDED_IDENTIFIER, vhdlParser.CHARACTER_LITERAL, vhdlParser.STRING_LITERAL, vhdlParser.LPAREN, vhdlParser.SHIFT_LEFT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2555
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vhdlParser.KW_PROCESS or _la==vhdlParser.KW_POSTPONED or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (vhdlParser.KW_WITH - 72)) | (1 << (vhdlParser.KW_ASSERT - 72)) | (1 << (vhdlParser.BASIC_IDENTIFIER - 72)) | (1 << (vhdlParser.EXTENDED_IDENTIFIER - 72)) | (1 << (vhdlParser.CHARACTER_LITERAL - 72)) | (1 << (vhdlParser.STRING_LITERAL - 72)) | (1 << (vhdlParser.LPAREN - 72)) | (1 << (vhdlParser.SHIFT_LEFT - 72)))) != 0):
                    self.state = 2552
                    self.concurrent_statement()
                    self.state = 2557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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 Generate_statement_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_BEGIN(self):
            return self.getToken(vhdlParser.KW_BEGIN, 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 concurrent_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.Concurrent_statementContext)
            else:
                return self.getTypedRuleContext(vhdlParser.Concurrent_statementContext,i)


        def getRuleIndex(self):
            return vhdlParser.RULE_generate_statement_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGenerate_statement_body" ):
                listener.enterGenerate_statement_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGenerate_statement_body" ):
                listener.exitGenerate_statement_body(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGenerate_statement_body" ):
                return visitor.visitGenerate_statement_body(self)
            else:
                return visitor.visitChildren(self)




    def generate_statement_body(self):

        localctx = vhdlParser.Generate_statement_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 484, self.RULE_generate_statement_body)
        self._la = 0 # Token type
        try:
            self.state = 2579
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,293,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2563
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_COMPONENT) | (1 << vhdlParser.KW_GROUP) | (1 << vhdlParser.KW_FILE) | (1 << vhdlParser.KW_PURE) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_SHARED) | (1 << vhdlParser.KW_SIGNAL) | (1 << vhdlParser.KW_DISCONNECT) | (1 << vhdlParser.KW_PROCEDURE) | (1 << vhdlParser.KW_ATTRIBUTE) | (1 << vhdlParser.KW_VARIABLE) | (1 << vhdlParser.KW_SUBTYPE) | (1 << vhdlParser.KW_CONSTANT) | (1 << vhdlParser.KW_FUNCTION))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (vhdlParser.KW_ALIAS - 65)) | (1 << (vhdlParser.KW_IMPURE - 65)) | (1 << (vhdlParser.KW_PACKAGE - 65)) | (1 << (vhdlParser.KW_FOR - 65)) | (1 << (vhdlParser.KW_TYPE - 65)))) != 0):
                    self.state = 2560
                    self.block_declarative_item()
                    self.state = 2565
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2566
                self.match(vhdlParser.KW_BEGIN)
                self.state = 2570
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,291,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2567
                        self.concurrent_statement() 
                    self.state = 2572
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,291,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2576
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,292,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2573
                        self.concurrent_statement() 
                    self.state = 2578
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,292,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelContext(ParserRuleContext):

        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_label

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabel" ):
                listener.enterLabel(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabel" ):
                listener.exitLabel(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabel" ):
                return visitor.visitLabel(self)
            else:
                return visitor.visitChildren(self)




    def label(self):

        localctx = vhdlParser.LabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 486, self.RULE_label)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2581
            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 Use_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_USE(self):
            return self.getToken(vhdlParser.KW_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, 488, self.RULE_use_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2583
            self.match(vhdlParser.KW_USE)
            self.state = 2584
            self.selected_name()
            self.state = 2589
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2585
                self.match(vhdlParser.COMMA)
                self.state = 2586
                self.selected_name()
                self.state = 2591
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2592
            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 Design_fileContext(ParserRuleContext):

        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, 490, self.RULE_design_file)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vhdlParser.KW_CONTEXT) | (1 << vhdlParser.KW_ENTITY) | (1 << vhdlParser.KW_USE) | (1 << vhdlParser.KW_LIBRARY))) != 0) or ((((_la - 82)) & ~0x3f) == 0 and ((1 << (_la - 82)) & ((1 << (vhdlParser.KW_PACKAGE - 82)) | (1 << (vhdlParser.KW_CONFIGURATION - 82)) | (1 << (vhdlParser.KW_ARCHITECTURE - 82)))) != 0):
                self.state = 2594
                self.design_unit()
                self.state = 2599
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2600
            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):

        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, 492, self.RULE_design_unit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2602
            self.context_clause()
            self.state = 2603
            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 Library_unitContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primary_unit(self):
            return self.getTypedRuleContext(vhdlParser.Primary_unitContext,0)


        def secondary_unit(self):
            return self.getTypedRuleContext(vhdlParser.Secondary_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, 494, self.RULE_library_unit)
        try:
            self.state = 2607
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,296,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2605
                self.primary_unit()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2606
                self.secondary_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 Primary_unitContext(ParserRuleContext):

        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 package_instantiation_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Package_instantiation_declarationContext,0)


        def context_declaration(self):
            return self.getTypedRuleContext(vhdlParser.Context_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, 496, self.RULE_primary_unit)
        try:
            self.state = 2614
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,297,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2609
                self.entity_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2610
                self.configuration_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2611
                self.package_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2612
                self.package_instantiation_declaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2613
                self.context_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 Secondary_unitContext(ParserRuleContext):

        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, 498, self.RULE_secondary_unit)
        try:
            self.state = 2618
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_ARCHITECTURE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2616
                self.architecture_body()
                pass
            elif token in [vhdlParser.KW_PACKAGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2617
                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 Library_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_LIBRARY(self):
            return self.getToken(vhdlParser.KW_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, 500, self.RULE_library_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2620
            self.match(vhdlParser.KW_LIBRARY)
            self.state = 2621
            self.logical_name_list()
            self.state = 2622
            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 Logical_name_listContext(ParserRuleContext):

        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 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, 502, self.RULE_logical_name_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2624
            self.identifier_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Context_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_CONTEXT(self, i:int=None):
            if i is None:
                return self.getTokens(vhdlParser.KW_CONTEXT)
            else:
                return self.getToken(vhdlParser.KW_CONTEXT, i)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vhdlParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(vhdlParser.IdentifierContext,i)


        def KW_IS(self):
            return self.getToken(vhdlParser.KW_IS, 0)

        def context_clause(self):
            return self.getTypedRuleContext(vhdlParser.Context_clauseContext,0)


        def KW_END(self):
            return self.getToken(vhdlParser.KW_END, 0)

        def SEMI(self):
            return self.getToken(vhdlParser.SEMI, 0)

        def getRuleIndex(self):
            return vhdlParser.RULE_context_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContext_declaration" ):
                listener.enterContext_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContext_declaration" ):
                listener.exitContext_declaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContext_declaration" ):
                return visitor.visitContext_declaration(self)
            else:
                return visitor.visitChildren(self)




    def context_declaration(self):

        localctx = vhdlParser.Context_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 504, self.RULE_context_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2626
            self.match(vhdlParser.KW_CONTEXT)
            self.state = 2627
            self.identifier()
            self.state = 2628
            self.match(vhdlParser.KW_IS)
            self.state = 2629
            self.context_clause()
            self.state = 2630
            self.match(vhdlParser.KW_END)
            self.state = 2632
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.KW_CONTEXT:
                self.state = 2631
                self.match(vhdlParser.KW_CONTEXT)


            self.state = 2635
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vhdlParser.BASIC_IDENTIFIER or _la==vhdlParser.EXTENDED_IDENTIFIER:
                self.state = 2634
                self.identifier()


            self.state = 2637
            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 Context_clauseContext(ParserRuleContext):

        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, 506, self.RULE_context_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2642
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,301,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2639
                    self.context_item() 
                self.state = 2644
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,301,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 Context_itemContext(ParserRuleContext):

        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 context_reference(self):
            return self.getTypedRuleContext(vhdlParser.Context_referenceContext,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, 508, self.RULE_context_item)
        try:
            self.state = 2648
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vhdlParser.KW_LIBRARY]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2645
                self.library_clause()
                pass
            elif token in [vhdlParser.KW_USE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2646
                self.use_clause()
                pass
            elif token in [vhdlParser.KW_CONTEXT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2647
                self.context_reference()
                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_referenceContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def KW_CONTEXT(self):
            return self.getToken(vhdlParser.KW_CONTEXT, 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_context_reference

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContext_reference" ):
                listener.enterContext_reference(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContext_reference" ):
                listener.exitContext_reference(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContext_reference" ):
                return visitor.visitContext_reference(self)
            else:
                return visitor.visitChildren(self)




    def context_reference(self):

        localctx = vhdlParser.Context_referenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 510, self.RULE_context_reference)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2650
            self.match(vhdlParser.KW_CONTEXT)
            self.state = 2651
            self.selected_name()
            self.state = 2656
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vhdlParser.COMMA:
                self.state = 2652
                self.match(vhdlParser.COMMA)
                self.state = 2653
                self.selected_name()
                self.state = 2658
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2659
            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 IdentifierContext(ParserRuleContext):

        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, 512, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2661
            _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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[2] = self.name_sempred
        self._predicates[156] = self.expression_sempred
        self._predicates[157] = self.simple_expression_sempred
        self._predicates[197] = self.conditional_waveforms_sempred
        self._predicates[199] = self.conditional_expressions_sempred
        self._predicates[211] = self.if_statement_sempred
        self._predicates[238] = self.if_generate_statement_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def name_sempred(self, localctx:NameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 1)
         

    def simple_expression_sempred(self, localctx:Simple_expressionContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         

    def conditional_waveforms_sempred(self, localctx:Conditional_waveformsContext, predIndex:int):
            if predIndex == 6:
                return self._input.LA(1) !=vhdlParser.KW_ELSE
         

    def conditional_expressions_sempred(self, localctx:Conditional_expressionsContext, predIndex:int):
            if predIndex == 7:
                return self._input.LA(1) != vhdlParser.KW_ELSE
         

    def if_statement_sempred(self, localctx:If_statementContext, predIndex:int):
            if predIndex == 8:
                return self._input.LA(1) != vhdlParser.KW_ELSE

         

    def if_generate_statement_sempred(self, localctx:If_generate_statementContext, predIndex:int):
            if predIndex == 9:
                return self._input.LA(1) != vhdlParser.KW_ELSE
