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


class vbaParser ( Parser ):

    grammarFileName = "vba.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "','", "';'", "'#'", "'.'", "'!'", "'%'", 
                     "'@'", "'$'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<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>", 
                     "'''", "':'", "'_'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "ACCESS", "ADDRESSOF", "ALIAS", "AND", 
                      "ATTRIBUTE", "APPACTIVATE", "APPEND", "AS", "BEGIN", 
                      "BEEP", "BINARY", "BOOLEAN", "BYVAL", "BYREF", "BYTE", 
                      "CALL", "CASE", "CHDIR", "CHDRIVE", "CLASS", "CLOSE", 
                      "COLLECTION", "CONST", "DATABASE", "DATE", "DECLARE", 
                      "DEFBOOL", "DEFBYTE", "DEFDATE", "DEFDBL", "DEFDEC", 
                      "DEFCUR", "DEFINT", "DEFLNG", "DEFOBJ", "DEFSNG", 
                      "DEFSTR", "DEFVAR", "DELETESETTING", "DIM", "DO", 
                      "DOUBLE", "EACH", "ELSE", "ELSEIF", "END_ENUM", "END_FUNCTION", 
                      "END_IF", "END_PROPERTY", "END_SELECT", "END_SUB", 
                      "END_TYPE", "END_WITH", "END", "ENUM", "EQV", "ERASE", 
                      "ERROR", "EVENT", "EXIT_DO", "EXIT_FOR", "EXIT_FUNCTION", 
                      "EXIT_PROPERTY", "EXIT_SUB", "FALSE", "FILECOPY", 
                      "FRIEND", "FOR", "FUNCTION", "GET", "GLOBAL", "GOSUB", 
                      "GOTO", "IF", "IMP", "IMPLEMENTS", "IN", "INPUT", 
                      "IS", "INTEGER", "KILL", "LOAD", "LOCK", "LONG", "LOOP", 
                      "LEN", "LET", "LIB", "LIKE", "LINE_INPUT", "LOCK_READ", 
                      "LOCK_WRITE", "LOCK_READ_WRITE", "LSET", "MACRO_CONST", 
                      "MACRO_IF", "MACRO_ELSEIF", "MACRO_ELSE", "MACRO_END_IF", 
                      "ME", "MID", "MKDIR", "MOD", "NAME", "NEXT", "NEW", 
                      "NOT", "NOTHING", "NULL_", "ON", "ON_ERROR", "ON_LOCAL_ERROR", 
                      "OPEN", "OPTIONAL", "OPTION_BASE", "OPTION_EXPLICIT", 
                      "OPTION_COMPARE", "OPTION_PRIVATE_MODULE", "OR", "OUTPUT", 
                      "PARAMARRAY", "PRESERVE", "PRINT", "PRIVATE", "PROPERTY_GET", 
                      "PROPERTY_LET", "PROPERTY_SET", "PTRSAFE", "PUBLIC", 
                      "PUT", "RANDOM", "RANDOMIZE", "RAISEEVENT", "READ", 
                      "READ_WRITE", "REDIM", "REM", "RESET", "RESUME", "RETURN", 
                      "RMDIR", "RSET", "SAVEPICTURE", "SAVESETTING", "SEEK", 
                      "SELECT", "SENDKEYS", "SET", "SETATTR", "SHARED", 
                      "SINGLE", "SPC", "STATIC", "STEP", "STOP", "STRING", 
                      "SUB", "TAB", "TEXT", "THEN", "TIME", "TO", "TRUE", 
                      "TYPE", "TYPEOF", "UNLOAD", "UNLOCK", "UNTIL", "VARIANT", 
                      "VERSION", "WEND", "WHILE", "WIDTH", "WITH", "WITHEVENTS", 
                      "WRITE", "XOR", "AMPERSAND", "ASSIGN", "DIV", "EQ", 
                      "GEQ", "GT", "LEQ", "LPAREN", "LT", "MINUS", "MINUS_EQ", 
                      "MULT", "NEQ", "PLUS", "PLUS_EQ", "POW", "RPAREN", 
                      "L_SQUARE_BRACKET", "R_SQUARE_BRACKET", "STRINGLITERAL", 
                      "OCTLITERAL", "HEXLITERAL", "SHORTLITERAL", "INTEGERLITERAL", 
                      "DOUBLELITERAL", "DATELITERAL", "LINE_CONTINUATION", 
                      "NEWLINE", "REMCOMMENT", "COMMENT", "SINGLEQUOTE", 
                      "COLON", "UNDERSCORE", "WS", "IDENTIFIER" ]

    RULE_startRule = 0
    RULE_module = 1
    RULE_moduleHeader = 2
    RULE_moduleConfig = 3
    RULE_moduleConfigElement = 4
    RULE_moduleAttributes = 5
    RULE_moduleDeclarations = 6
    RULE_moduleOption = 7
    RULE_moduleDeclarationsElement = 8
    RULE_macroStmt = 9
    RULE_moduleBody = 10
    RULE_moduleBodyElement = 11
    RULE_attributeStmt = 12
    RULE_block = 13
    RULE_blockStmt = 14
    RULE_appactivateStmt = 15
    RULE_beepStmt = 16
    RULE_chdirStmt = 17
    RULE_chdriveStmt = 18
    RULE_closeStmt = 19
    RULE_constStmt = 20
    RULE_constSubStmt = 21
    RULE_dateStmt = 22
    RULE_declareStmt = 23
    RULE_deftypeStmt = 24
    RULE_deleteSettingStmt = 25
    RULE_doLoopStmt = 26
    RULE_endStmt = 27
    RULE_enumerationStmt = 28
    RULE_enumerationStmt_Constant = 29
    RULE_eraseStmt = 30
    RULE_errorStmt = 31
    RULE_eventStmt = 32
    RULE_exitStmt = 33
    RULE_filecopyStmt = 34
    RULE_forEachStmt = 35
    RULE_forNextStmt = 36
    RULE_functionStmt = 37
    RULE_getStmt = 38
    RULE_goSubStmt = 39
    RULE_goToStmt = 40
    RULE_ifThenElseStmt = 41
    RULE_ifBlockStmt = 42
    RULE_ifConditionStmt = 43
    RULE_ifElseIfBlockStmt = 44
    RULE_ifElseBlockStmt = 45
    RULE_implementsStmt = 46
    RULE_inputStmt = 47
    RULE_killStmt = 48
    RULE_letStmt = 49
    RULE_lineInputStmt = 50
    RULE_loadStmt = 51
    RULE_lockStmt = 52
    RULE_lsetStmt = 53
    RULE_macroConstStmt = 54
    RULE_macroIfThenElseStmt = 55
    RULE_macroIfBlockStmt = 56
    RULE_macroElseIfBlockStmt = 57
    RULE_macroElseBlockStmt = 58
    RULE_midStmt = 59
    RULE_mkdirStmt = 60
    RULE_nameStmt = 61
    RULE_onErrorStmt = 62
    RULE_onGoToStmt = 63
    RULE_onGoSubStmt = 64
    RULE_openStmt = 65
    RULE_outputList = 66
    RULE_outputList_Expression = 67
    RULE_printStmt = 68
    RULE_propertyGetStmt = 69
    RULE_propertySetStmt = 70
    RULE_propertyLetStmt = 71
    RULE_putStmt = 72
    RULE_raiseEventStmt = 73
    RULE_randomizeStmt = 74
    RULE_redimStmt = 75
    RULE_redimSubStmt = 76
    RULE_resetStmt = 77
    RULE_resumeStmt = 78
    RULE_returnStmt = 79
    RULE_rmdirStmt = 80
    RULE_rsetStmt = 81
    RULE_savepictureStmt = 82
    RULE_saveSettingStmt = 83
    RULE_seekStmt = 84
    RULE_selectCaseStmt = 85
    RULE_sC_Selection = 86
    RULE_sC_Case = 87
    RULE_sC_Cond = 88
    RULE_sendkeysStmt = 89
    RULE_setattrStmt = 90
    RULE_setStmt = 91
    RULE_stopStmt = 92
    RULE_subStmt = 93
    RULE_timeStmt = 94
    RULE_typeStmt = 95
    RULE_typeStmt_Element = 96
    RULE_typeOfStmt = 97
    RULE_unloadStmt = 98
    RULE_unlockStmt = 99
    RULE_valueStmt = 100
    RULE_variableStmt = 101
    RULE_variableListStmt = 102
    RULE_variableSubStmt = 103
    RULE_whileWendStmt = 104
    RULE_widthStmt = 105
    RULE_withStmt = 106
    RULE_writeStmt = 107
    RULE_fileNumber = 108
    RULE_explicitCallStmt = 109
    RULE_eCS_ProcedureCall = 110
    RULE_eCS_MemberProcedureCall = 111
    RULE_implicitCallStmt_InBlock = 112
    RULE_iCS_B_MemberProcedureCall = 113
    RULE_iCS_B_ProcedureCall = 114
    RULE_implicitCallStmt_InStmt = 115
    RULE_iCS_S_VariableOrProcedureCall = 116
    RULE_iCS_S_ProcedureOrArrayCall = 117
    RULE_iCS_S_MembersCall = 118
    RULE_iCS_S_MemberCall = 119
    RULE_iCS_S_DictionaryCall = 120
    RULE_argsCall = 121
    RULE_argCall = 122
    RULE_dictionaryCallStmt = 123
    RULE_argList = 124
    RULE_arg = 125
    RULE_argDefaultValue = 126
    RULE_subscripts = 127
    RULE_subscript_ = 128
    RULE_ambiguousIdentifier = 129
    RULE_asTypeClause = 130
    RULE_baseType = 131
    RULE_certainIdentifier = 132
    RULE_comparisonOperator = 133
    RULE_complexType = 134
    RULE_fieldLength = 135
    RULE_letterrange = 136
    RULE_lineLabel = 137
    RULE_literal = 138
    RULE_type_ = 139
    RULE_typeHint = 140
    RULE_visibility = 141
    RULE_ambiguousKeyword = 142
    RULE_remComment = 143
    RULE_comment = 144
    RULE_endOfLine = 145
    RULE_endOfStatement = 146

    ruleNames =  [ "startRule", "module", "moduleHeader", "moduleConfig", 
                   "moduleConfigElement", "moduleAttributes", "moduleDeclarations", 
                   "moduleOption", "moduleDeclarationsElement", "macroStmt", 
                   "moduleBody", "moduleBodyElement", "attributeStmt", "block", 
                   "blockStmt", "appactivateStmt", "beepStmt", "chdirStmt", 
                   "chdriveStmt", "closeStmt", "constStmt", "constSubStmt", 
                   "dateStmt", "declareStmt", "deftypeStmt", "deleteSettingStmt", 
                   "doLoopStmt", "endStmt", "enumerationStmt", "enumerationStmt_Constant", 
                   "eraseStmt", "errorStmt", "eventStmt", "exitStmt", "filecopyStmt", 
                   "forEachStmt", "forNextStmt", "functionStmt", "getStmt", 
                   "goSubStmt", "goToStmt", "ifThenElseStmt", "ifBlockStmt", 
                   "ifConditionStmt", "ifElseIfBlockStmt", "ifElseBlockStmt", 
                   "implementsStmt", "inputStmt", "killStmt", "letStmt", 
                   "lineInputStmt", "loadStmt", "lockStmt", "lsetStmt", 
                   "macroConstStmt", "macroIfThenElseStmt", "macroIfBlockStmt", 
                   "macroElseIfBlockStmt", "macroElseBlockStmt", "midStmt", 
                   "mkdirStmt", "nameStmt", "onErrorStmt", "onGoToStmt", 
                   "onGoSubStmt", "openStmt", "outputList", "outputList_Expression", 
                   "printStmt", "propertyGetStmt", "propertySetStmt", "propertyLetStmt", 
                   "putStmt", "raiseEventStmt", "randomizeStmt", "redimStmt", 
                   "redimSubStmt", "resetStmt", "resumeStmt", "returnStmt", 
                   "rmdirStmt", "rsetStmt", "savepictureStmt", "saveSettingStmt", 
                   "seekStmt", "selectCaseStmt", "sC_Selection", "sC_Case", 
                   "sC_Cond", "sendkeysStmt", "setattrStmt", "setStmt", 
                   "stopStmt", "subStmt", "timeStmt", "typeStmt", "typeStmt_Element", 
                   "typeOfStmt", "unloadStmt", "unlockStmt", "valueStmt", 
                   "variableStmt", "variableListStmt", "variableSubStmt", 
                   "whileWendStmt", "widthStmt", "withStmt", "writeStmt", 
                   "fileNumber", "explicitCallStmt", "eCS_ProcedureCall", 
                   "eCS_MemberProcedureCall", "implicitCallStmt_InBlock", 
                   "iCS_B_MemberProcedureCall", "iCS_B_ProcedureCall", "implicitCallStmt_InStmt", 
                   "iCS_S_VariableOrProcedureCall", "iCS_S_ProcedureOrArrayCall", 
                   "iCS_S_MembersCall", "iCS_S_MemberCall", "iCS_S_DictionaryCall", 
                   "argsCall", "argCall", "dictionaryCallStmt", "argList", 
                   "arg", "argDefaultValue", "subscripts", "subscript_", 
                   "ambiguousIdentifier", "asTypeClause", "baseType", "certainIdentifier", 
                   "comparisonOperator", "complexType", "fieldLength", "letterrange", 
                   "lineLabel", "literal", "type_", "typeHint", "visibility", 
                   "ambiguousKeyword", "remComment", "comment", "endOfLine", 
                   "endOfStatement" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    ACCESS=9
    ADDRESSOF=10
    ALIAS=11
    AND=12
    ATTRIBUTE=13
    APPACTIVATE=14
    APPEND=15
    AS=16
    BEGIN=17
    BEEP=18
    BINARY=19
    BOOLEAN=20
    BYVAL=21
    BYREF=22
    BYTE=23
    CALL=24
    CASE=25
    CHDIR=26
    CHDRIVE=27
    CLASS=28
    CLOSE=29
    COLLECTION=30
    CONST=31
    DATABASE=32
    DATE=33
    DECLARE=34
    DEFBOOL=35
    DEFBYTE=36
    DEFDATE=37
    DEFDBL=38
    DEFDEC=39
    DEFCUR=40
    DEFINT=41
    DEFLNG=42
    DEFOBJ=43
    DEFSNG=44
    DEFSTR=45
    DEFVAR=46
    DELETESETTING=47
    DIM=48
    DO=49
    DOUBLE=50
    EACH=51
    ELSE=52
    ELSEIF=53
    END_ENUM=54
    END_FUNCTION=55
    END_IF=56
    END_PROPERTY=57
    END_SELECT=58
    END_SUB=59
    END_TYPE=60
    END_WITH=61
    END=62
    ENUM=63
    EQV=64
    ERASE=65
    ERROR=66
    EVENT=67
    EXIT_DO=68
    EXIT_FOR=69
    EXIT_FUNCTION=70
    EXIT_PROPERTY=71
    EXIT_SUB=72
    FALSE=73
    FILECOPY=74
    FRIEND=75
    FOR=76
    FUNCTION=77
    GET=78
    GLOBAL=79
    GOSUB=80
    GOTO=81
    IF=82
    IMP=83
    IMPLEMENTS=84
    IN=85
    INPUT=86
    IS=87
    INTEGER=88
    KILL=89
    LOAD=90
    LOCK=91
    LONG=92
    LOOP=93
    LEN=94
    LET=95
    LIB=96
    LIKE=97
    LINE_INPUT=98
    LOCK_READ=99
    LOCK_WRITE=100
    LOCK_READ_WRITE=101
    LSET=102
    MACRO_CONST=103
    MACRO_IF=104
    MACRO_ELSEIF=105
    MACRO_ELSE=106
    MACRO_END_IF=107
    ME=108
    MID=109
    MKDIR=110
    MOD=111
    NAME=112
    NEXT=113
    NEW=114
    NOT=115
    NOTHING=116
    NULL_=117
    ON=118
    ON_ERROR=119
    ON_LOCAL_ERROR=120
    OPEN=121
    OPTIONAL=122
    OPTION_BASE=123
    OPTION_EXPLICIT=124
    OPTION_COMPARE=125
    OPTION_PRIVATE_MODULE=126
    OR=127
    OUTPUT=128
    PARAMARRAY=129
    PRESERVE=130
    PRINT=131
    PRIVATE=132
    PROPERTY_GET=133
    PROPERTY_LET=134
    PROPERTY_SET=135
    PTRSAFE=136
    PUBLIC=137
    PUT=138
    RANDOM=139
    RANDOMIZE=140
    RAISEEVENT=141
    READ=142
    READ_WRITE=143
    REDIM=144
    REM=145
    RESET=146
    RESUME=147
    RETURN=148
    RMDIR=149
    RSET=150
    SAVEPICTURE=151
    SAVESETTING=152
    SEEK=153
    SELECT=154
    SENDKEYS=155
    SET=156
    SETATTR=157
    SHARED=158
    SINGLE=159
    SPC=160
    STATIC=161
    STEP=162
    STOP=163
    STRING=164
    SUB=165
    TAB=166
    TEXT=167
    THEN=168
    TIME=169
    TO=170
    TRUE=171
    TYPE=172
    TYPEOF=173
    UNLOAD=174
    UNLOCK=175
    UNTIL=176
    VARIANT=177
    VERSION=178
    WEND=179
    WHILE=180
    WIDTH=181
    WITH=182
    WITHEVENTS=183
    WRITE=184
    XOR=185
    AMPERSAND=186
    ASSIGN=187
    DIV=188
    EQ=189
    GEQ=190
    GT=191
    LEQ=192
    LPAREN=193
    LT=194
    MINUS=195
    MINUS_EQ=196
    MULT=197
    NEQ=198
    PLUS=199
    PLUS_EQ=200
    POW=201
    RPAREN=202
    L_SQUARE_BRACKET=203
    R_SQUARE_BRACKET=204
    STRINGLITERAL=205
    OCTLITERAL=206
    HEXLITERAL=207
    SHORTLITERAL=208
    INTEGERLITERAL=209
    DOUBLELITERAL=210
    DATELITERAL=211
    LINE_CONTINUATION=212
    NEWLINE=213
    REMCOMMENT=214
    COMMENT=215
    SINGLEQUOTE=216
    COLON=217
    UNDERSCORE=218
    WS=219
    IDENTIFIER=220

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




    class StartRuleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def module(self):
            return self.getTypedRuleContext(vbaParser.ModuleContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_startRule

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

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




    def startRule(self):

        localctx = vbaParser.StartRuleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_startRule)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.module()
            self.state = 295
            self.match(vbaParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModuleContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def moduleHeader(self):
            return self.getTypedRuleContext(vbaParser.ModuleHeaderContext,0)


        def moduleConfig(self):
            return self.getTypedRuleContext(vbaParser.ModuleConfigContext,0)


        def moduleAttributes(self):
            return self.getTypedRuleContext(vbaParser.ModuleAttributesContext,0)


        def moduleDeclarations(self):
            return self.getTypedRuleContext(vbaParser.ModuleDeclarationsContext,0)


        def moduleBody(self):
            return self.getTypedRuleContext(vbaParser.ModuleBodyContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_module

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

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




    def module(self):

        localctx = vbaParser.ModuleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_module)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.state = 297
                self.match(vbaParser.WS)


            self.state = 303
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 300
                    self.endOfLine() 
                self.state = 305
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

            self.state = 313
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.VERSION:
                self.state = 306
                self.moduleHeader()
                self.state = 310
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 307
                        self.endOfLine() 
                    self.state = 312
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,2,self._ctx)



            self.state = 316
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.BEGIN:
                self.state = 315
                self.moduleConfig()


            self.state = 321
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 318
                    self.endOfLine() 
                self.state = 323
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)

            self.state = 325
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.ATTRIBUTE:
                self.state = 324
                self.moduleAttributes()


            self.state = 330
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 327
                    self.endOfLine() 
                self.state = 332
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

            self.state = 334
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 333
                self.moduleDeclarations()


            self.state = 339
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 336
                    self.endOfLine() 
                self.state = 341
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.FUNCTION - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.MACRO_CONST - 75)) | (1 << (vbaParser.MACRO_IF - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PROPERTY_GET - 75)) | (1 << (vbaParser.PROPERTY_LET - 75)) | (1 << (vbaParser.PROPERTY_SET - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0) or _la==vbaParser.STATIC or _la==vbaParser.SUB:
                self.state = 342
                self.moduleBody()


            self.state = 348
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 345
                    self.endOfLine() 
                self.state = 350
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

            self.state = 352
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 351
                self.match(vbaParser.WS)


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


    class ModuleHeaderContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VERSION(self):
            return self.getToken(vbaParser.VERSION, 0)

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

        def DOUBLELITERAL(self):
            return self.getToken(vbaParser.DOUBLELITERAL, 0)

        def CLASS(self):
            return self.getToken(vbaParser.CLASS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_moduleHeader

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

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




    def moduleHeader(self):

        localctx = vbaParser.ModuleHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_moduleHeader)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 354
            self.match(vbaParser.VERSION)
            self.state = 355
            self.match(vbaParser.WS)
            self.state = 356
            self.match(vbaParser.DOUBLELITERAL)
            self.state = 357
            self.match(vbaParser.WS)
            self.state = 358
            self.match(vbaParser.CLASS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModuleConfigContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def moduleConfigElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleConfigElementContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleConfigElementContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleConfig

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

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




    def moduleConfig(self):

        localctx = vbaParser.ModuleConfigContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_moduleConfig)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.match(vbaParser.BEGIN)
            self.state = 364
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & ((1 << (vbaParser.NEWLINE - 213)) | (1 << (vbaParser.REMCOMMENT - 213)) | (1 << (vbaParser.COMMENT - 213)) | (1 << (vbaParser.WS - 213)))) != 0):
                self.state = 361
                self.endOfLine()
                self.state = 366
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 368 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 367
                    self.moduleConfigElement()

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

            self.state = 372
            self.match(vbaParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModuleConfigElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def literal(self):
            return self.getTypedRuleContext(vbaParser.LiteralContext,0)


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

        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleConfigElement

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

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




    def moduleConfigElement(self):

        localctx = vbaParser.ModuleConfigElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_moduleConfigElement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.ambiguousIdentifier()
            self.state = 376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 375
                self.match(vbaParser.WS)


            self.state = 378
            self.match(vbaParser.EQ)
            self.state = 380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 379
                self.match(vbaParser.WS)


            self.state = 382
            self.literal()
            self.state = 386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & ((1 << (vbaParser.NEWLINE - 213)) | (1 << (vbaParser.REMCOMMENT - 213)) | (1 << (vbaParser.COMMENT - 213)) | (1 << (vbaParser.WS - 213)))) != 0):
                self.state = 383
                self.endOfLine()
                self.state = 388
                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 ModuleAttributesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attributeStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AttributeStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.AttributeStmtContext,i)


        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleAttributes

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

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




    def moduleAttributes(self):

        localctx = vbaParser.ModuleAttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_moduleAttributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 395 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 389
                self.attributeStmt()
                self.state = 391 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 390
                        self.endOfLine()

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

                self.state = 397 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==vbaParser.ATTRIBUTE):
                    break

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


    class ModuleDeclarationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def moduleDeclarationsElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleDeclarationsElementContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleDeclarationsElementContext,i)


        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleDeclarations

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

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




    def moduleDeclarations(self):

        localctx = vbaParser.ModuleDeclarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_moduleDeclarations)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.moduleDeclarationsElement()
            self.state = 409
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 401 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 400
                            self.endOfLine()

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

                    self.state = 405
                    self.moduleDeclarationsElement() 
                self.state = 411
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)

            self.state = 415
            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 = 412
                    self.endOfLine() 
                self.state = 417
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,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 ModuleOptionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleOption

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



    class OptionExplicitStmtContext(ModuleOptionContext):

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

        def OPTION_EXPLICIT(self):
            return self.getToken(vbaParser.OPTION_EXPLICIT, 0)

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

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


    class OptionBaseStmtContext(ModuleOptionContext):

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

        def OPTION_BASE(self):
            return self.getToken(vbaParser.OPTION_BASE, 0)
        def WS(self):
            return self.getToken(vbaParser.WS, 0)
        def SHORTLITERAL(self):
            return self.getToken(vbaParser.SHORTLITERAL, 0)

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

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


    class OptionPrivateModuleStmtContext(ModuleOptionContext):

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

        def OPTION_PRIVATE_MODULE(self):
            return self.getToken(vbaParser.OPTION_PRIVATE_MODULE, 0)

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

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


    class OptionCompareStmtContext(ModuleOptionContext):

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

        def OPTION_COMPARE(self):
            return self.getToken(vbaParser.OPTION_COMPARE, 0)
        def WS(self):
            return self.getToken(vbaParser.WS, 0)
        def BINARY(self):
            return self.getToken(vbaParser.BINARY, 0)
        def TEXT(self):
            return self.getToken(vbaParser.TEXT, 0)
        def DATABASE(self):
            return self.getToken(vbaParser.DATABASE, 0)

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

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



    def moduleOption(self):

        localctx = vbaParser.ModuleOptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_moduleOption)
        self._la = 0 # Token type
        try:
            self.state = 426
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.OPTION_BASE]:
                localctx = vbaParser.OptionBaseStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 418
                self.match(vbaParser.OPTION_BASE)
                self.state = 419
                self.match(vbaParser.WS)
                self.state = 420
                self.match(vbaParser.SHORTLITERAL)
                pass
            elif token in [vbaParser.OPTION_COMPARE]:
                localctx = vbaParser.OptionCompareStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 421
                self.match(vbaParser.OPTION_COMPARE)
                self.state = 422
                self.match(vbaParser.WS)
                self.state = 423
                _la = self._input.LA(1)
                if not(_la==vbaParser.BINARY or _la==vbaParser.DATABASE or _la==vbaParser.TEXT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [vbaParser.OPTION_EXPLICIT]:
                localctx = vbaParser.OptionExplicitStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 424
                self.match(vbaParser.OPTION_EXPLICIT)
                pass
            elif token in [vbaParser.OPTION_PRIVATE_MODULE]:
                localctx = vbaParser.OptionPrivateModuleStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 425
                self.match(vbaParser.OPTION_PRIVATE_MODULE)
                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 ModuleDeclarationsElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def comment(self):
            return self.getTypedRuleContext(vbaParser.CommentContext,0)


        def declareStmt(self):
            return self.getTypedRuleContext(vbaParser.DeclareStmtContext,0)


        def enumerationStmt(self):
            return self.getTypedRuleContext(vbaParser.EnumerationStmtContext,0)


        def eventStmt(self):
            return self.getTypedRuleContext(vbaParser.EventStmtContext,0)


        def constStmt(self):
            return self.getTypedRuleContext(vbaParser.ConstStmtContext,0)


        def implementsStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplementsStmtContext,0)


        def variableStmt(self):
            return self.getTypedRuleContext(vbaParser.VariableStmtContext,0)


        def moduleOption(self):
            return self.getTypedRuleContext(vbaParser.ModuleOptionContext,0)


        def typeStmt(self):
            return self.getTypedRuleContext(vbaParser.TypeStmtContext,0)


        def macroStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleDeclarationsElement

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

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




    def moduleDeclarationsElement(self):

        localctx = vbaParser.ModuleDeclarationsElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_moduleDeclarationsElement)
        try:
            self.state = 438
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 428
                self.comment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 429
                self.declareStmt()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 430
                self.enumerationStmt()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 431
                self.eventStmt()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 432
                self.constStmt()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 433
                self.implementsStmt()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 434
                self.variableStmt()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 435
                self.moduleOption()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 436
                self.typeStmt()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 437
                self.macroStmt()
                pass


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


    class MacroStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def macroConstStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroConstStmtContext,0)


        def macroIfThenElseStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroIfThenElseStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_macroStmt

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

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




    def macroStmt(self):

        localctx = vbaParser.MacroStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_macroStmt)
        try:
            self.state = 442
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.MACRO_CONST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 440
                self.macroConstStmt()
                pass
            elif token in [vbaParser.MACRO_IF]:
                self.enterOuterAlt(localctx, 2)
                self.state = 441
                self.macroIfThenElseStmt()
                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 ModuleBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def moduleBodyElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleBodyElementContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleBodyElementContext,i)


        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleBody

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

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




    def moduleBody(self):

        localctx = vbaParser.ModuleBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_moduleBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 444
            self.moduleBodyElement()
            self.state = 454
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 446 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 445
                        self.endOfLine()
                        self.state = 448 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & ((1 << (vbaParser.NEWLINE - 213)) | (1 << (vbaParser.REMCOMMENT - 213)) | (1 << (vbaParser.COMMENT - 213)) | (1 << (vbaParser.WS - 213)))) != 0)):
                            break

                    self.state = 450
                    self.moduleBodyElement() 
                self.state = 456
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,27,self._ctx)

            self.state = 460
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 457
                    self.endOfLine() 
                self.state = 462
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,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 ModuleBodyElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionStmt(self):
            return self.getTypedRuleContext(vbaParser.FunctionStmtContext,0)


        def propertyGetStmt(self):
            return self.getTypedRuleContext(vbaParser.PropertyGetStmtContext,0)


        def propertySetStmt(self):
            return self.getTypedRuleContext(vbaParser.PropertySetStmtContext,0)


        def propertyLetStmt(self):
            return self.getTypedRuleContext(vbaParser.PropertyLetStmtContext,0)


        def subStmt(self):
            return self.getTypedRuleContext(vbaParser.SubStmtContext,0)


        def macroStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_moduleBodyElement

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

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




    def moduleBodyElement(self):

        localctx = vbaParser.ModuleBodyElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_moduleBodyElement)
        try:
            self.state = 469
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 463
                self.functionStmt()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 464
                self.propertyGetStmt()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 465
                self.propertySetStmt()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 466
                self.propertyLetStmt()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 467
                self.subStmt()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 468
                self.macroStmt()
                pass


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


    class AttributeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.LiteralContext)
            else:
                return self.getTypedRuleContext(vbaParser.LiteralContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_attributeStmt

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

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




    def attributeStmt(self):

        localctx = vbaParser.AttributeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_attributeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 471
            self.match(vbaParser.ATTRIBUTE)
            self.state = 472
            self.match(vbaParser.WS)
            self.state = 473
            self.implicitCallStmt_InStmt()
            self.state = 475
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 474
                self.match(vbaParser.WS)


            self.state = 477
            self.match(vbaParser.EQ)
            self.state = 479
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 478
                self.match(vbaParser.WS)


            self.state = 481
            self.literal()
            self.state = 492
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 483
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 482
                        self.match(vbaParser.WS)


                    self.state = 485
                    self.match(vbaParser.T__0)
                    self.state = 487
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 486
                        self.match(vbaParser.WS)


                    self.state = 489
                    self.literal() 
                self.state = 494
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,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 BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def blockStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.BlockStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.BlockStmtContext,i)


        def endOfStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfStatementContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfStatementContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_block

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

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




    def block(self):

        localctx = vbaParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 495
            self.blockStmt()
            self.state = 501
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 496
                    self.endOfStatement()
                    self.state = 497
                    self.blockStmt() 
                self.state = 503
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)

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


    class BlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lineLabel(self):
            return self.getTypedRuleContext(vbaParser.LineLabelContext,0)


        def appactivateStmt(self):
            return self.getTypedRuleContext(vbaParser.AppactivateStmtContext,0)


        def attributeStmt(self):
            return self.getTypedRuleContext(vbaParser.AttributeStmtContext,0)


        def beepStmt(self):
            return self.getTypedRuleContext(vbaParser.BeepStmtContext,0)


        def chdirStmt(self):
            return self.getTypedRuleContext(vbaParser.ChdirStmtContext,0)


        def chdriveStmt(self):
            return self.getTypedRuleContext(vbaParser.ChdriveStmtContext,0)


        def closeStmt(self):
            return self.getTypedRuleContext(vbaParser.CloseStmtContext,0)


        def constStmt(self):
            return self.getTypedRuleContext(vbaParser.ConstStmtContext,0)


        def dateStmt(self):
            return self.getTypedRuleContext(vbaParser.DateStmtContext,0)


        def deleteSettingStmt(self):
            return self.getTypedRuleContext(vbaParser.DeleteSettingStmtContext,0)


        def deftypeStmt(self):
            return self.getTypedRuleContext(vbaParser.DeftypeStmtContext,0)


        def doLoopStmt(self):
            return self.getTypedRuleContext(vbaParser.DoLoopStmtContext,0)


        def endStmt(self):
            return self.getTypedRuleContext(vbaParser.EndStmtContext,0)


        def eraseStmt(self):
            return self.getTypedRuleContext(vbaParser.EraseStmtContext,0)


        def errorStmt(self):
            return self.getTypedRuleContext(vbaParser.ErrorStmtContext,0)


        def exitStmt(self):
            return self.getTypedRuleContext(vbaParser.ExitStmtContext,0)


        def explicitCallStmt(self):
            return self.getTypedRuleContext(vbaParser.ExplicitCallStmtContext,0)


        def filecopyStmt(self):
            return self.getTypedRuleContext(vbaParser.FilecopyStmtContext,0)


        def forEachStmt(self):
            return self.getTypedRuleContext(vbaParser.ForEachStmtContext,0)


        def forNextStmt(self):
            return self.getTypedRuleContext(vbaParser.ForNextStmtContext,0)


        def getStmt(self):
            return self.getTypedRuleContext(vbaParser.GetStmtContext,0)


        def goSubStmt(self):
            return self.getTypedRuleContext(vbaParser.GoSubStmtContext,0)


        def goToStmt(self):
            return self.getTypedRuleContext(vbaParser.GoToStmtContext,0)


        def ifThenElseStmt(self):
            return self.getTypedRuleContext(vbaParser.IfThenElseStmtContext,0)


        def implementsStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplementsStmtContext,0)


        def inputStmt(self):
            return self.getTypedRuleContext(vbaParser.InputStmtContext,0)


        def killStmt(self):
            return self.getTypedRuleContext(vbaParser.KillStmtContext,0)


        def letStmt(self):
            return self.getTypedRuleContext(vbaParser.LetStmtContext,0)


        def lineInputStmt(self):
            return self.getTypedRuleContext(vbaParser.LineInputStmtContext,0)


        def loadStmt(self):
            return self.getTypedRuleContext(vbaParser.LoadStmtContext,0)


        def lockStmt(self):
            return self.getTypedRuleContext(vbaParser.LockStmtContext,0)


        def lsetStmt(self):
            return self.getTypedRuleContext(vbaParser.LsetStmtContext,0)


        def macroStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroStmtContext,0)


        def midStmt(self):
            return self.getTypedRuleContext(vbaParser.MidStmtContext,0)


        def mkdirStmt(self):
            return self.getTypedRuleContext(vbaParser.MkdirStmtContext,0)


        def nameStmt(self):
            return self.getTypedRuleContext(vbaParser.NameStmtContext,0)


        def onErrorStmt(self):
            return self.getTypedRuleContext(vbaParser.OnErrorStmtContext,0)


        def onGoToStmt(self):
            return self.getTypedRuleContext(vbaParser.OnGoToStmtContext,0)


        def onGoSubStmt(self):
            return self.getTypedRuleContext(vbaParser.OnGoSubStmtContext,0)


        def openStmt(self):
            return self.getTypedRuleContext(vbaParser.OpenStmtContext,0)


        def printStmt(self):
            return self.getTypedRuleContext(vbaParser.PrintStmtContext,0)


        def putStmt(self):
            return self.getTypedRuleContext(vbaParser.PutStmtContext,0)


        def raiseEventStmt(self):
            return self.getTypedRuleContext(vbaParser.RaiseEventStmtContext,0)


        def randomizeStmt(self):
            return self.getTypedRuleContext(vbaParser.RandomizeStmtContext,0)


        def redimStmt(self):
            return self.getTypedRuleContext(vbaParser.RedimStmtContext,0)


        def resetStmt(self):
            return self.getTypedRuleContext(vbaParser.ResetStmtContext,0)


        def resumeStmt(self):
            return self.getTypedRuleContext(vbaParser.ResumeStmtContext,0)


        def returnStmt(self):
            return self.getTypedRuleContext(vbaParser.ReturnStmtContext,0)


        def rmdirStmt(self):
            return self.getTypedRuleContext(vbaParser.RmdirStmtContext,0)


        def rsetStmt(self):
            return self.getTypedRuleContext(vbaParser.RsetStmtContext,0)


        def savepictureStmt(self):
            return self.getTypedRuleContext(vbaParser.SavepictureStmtContext,0)


        def saveSettingStmt(self):
            return self.getTypedRuleContext(vbaParser.SaveSettingStmtContext,0)


        def seekStmt(self):
            return self.getTypedRuleContext(vbaParser.SeekStmtContext,0)


        def selectCaseStmt(self):
            return self.getTypedRuleContext(vbaParser.SelectCaseStmtContext,0)


        def sendkeysStmt(self):
            return self.getTypedRuleContext(vbaParser.SendkeysStmtContext,0)


        def setattrStmt(self):
            return self.getTypedRuleContext(vbaParser.SetattrStmtContext,0)


        def setStmt(self):
            return self.getTypedRuleContext(vbaParser.SetStmtContext,0)


        def stopStmt(self):
            return self.getTypedRuleContext(vbaParser.StopStmtContext,0)


        def timeStmt(self):
            return self.getTypedRuleContext(vbaParser.TimeStmtContext,0)


        def unloadStmt(self):
            return self.getTypedRuleContext(vbaParser.UnloadStmtContext,0)


        def unlockStmt(self):
            return self.getTypedRuleContext(vbaParser.UnlockStmtContext,0)


        def variableStmt(self):
            return self.getTypedRuleContext(vbaParser.VariableStmtContext,0)


        def whileWendStmt(self):
            return self.getTypedRuleContext(vbaParser.WhileWendStmtContext,0)


        def widthStmt(self):
            return self.getTypedRuleContext(vbaParser.WidthStmtContext,0)


        def withStmt(self):
            return self.getTypedRuleContext(vbaParser.WithStmtContext,0)


        def writeStmt(self):
            return self.getTypedRuleContext(vbaParser.WriteStmtContext,0)


        def implicitCallStmt_InBlock(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InBlockContext,0)


        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_blockStmt

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

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




    def blockStmt(self):

        localctx = vbaParser.BlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_blockStmt)
        try:
            self.state = 574
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 506
                self.lineLabel()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 507
                self.appactivateStmt()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 508
                self.attributeStmt()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 509
                self.beepStmt()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 510
                self.chdirStmt()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 511
                self.chdriveStmt()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 512
                self.closeStmt()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 513
                self.constStmt()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 514
                self.dateStmt()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 515
                self.deleteSettingStmt()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 516
                self.deftypeStmt()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 517
                self.doLoopStmt()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 518
                self.endStmt()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 519
                self.eraseStmt()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 520
                self.errorStmt()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 521
                self.exitStmt()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 522
                self.explicitCallStmt()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 523
                self.filecopyStmt()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 524
                self.forEachStmt()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 525
                self.forNextStmt()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 526
                self.getStmt()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 527
                self.goSubStmt()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 528
                self.goToStmt()
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 529
                self.ifThenElseStmt()
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 530
                self.implementsStmt()
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 531
                self.inputStmt()
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 532
                self.killStmt()
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 533
                self.letStmt()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 534
                self.lineInputStmt()
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 535
                self.loadStmt()
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 536
                self.lockStmt()
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 537
                self.lsetStmt()
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 538
                self.macroStmt()
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 539
                self.midStmt()
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 540
                self.mkdirStmt()
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 541
                self.nameStmt()
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 542
                self.onErrorStmt()
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 543
                self.onGoToStmt()
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 544
                self.onGoSubStmt()
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 545
                self.openStmt()
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 546
                self.printStmt()
                pass

            elif la_ == 42:
                self.enterOuterAlt(localctx, 42)
                self.state = 547
                self.putStmt()
                pass

            elif la_ == 43:
                self.enterOuterAlt(localctx, 43)
                self.state = 548
                self.raiseEventStmt()
                pass

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 549
                self.randomizeStmt()
                pass

            elif la_ == 45:
                self.enterOuterAlt(localctx, 45)
                self.state = 550
                self.redimStmt()
                pass

            elif la_ == 46:
                self.enterOuterAlt(localctx, 46)
                self.state = 551
                self.resetStmt()
                pass

            elif la_ == 47:
                self.enterOuterAlt(localctx, 47)
                self.state = 552
                self.resumeStmt()
                pass

            elif la_ == 48:
                self.enterOuterAlt(localctx, 48)
                self.state = 553
                self.returnStmt()
                pass

            elif la_ == 49:
                self.enterOuterAlt(localctx, 49)
                self.state = 554
                self.rmdirStmt()
                pass

            elif la_ == 50:
                self.enterOuterAlt(localctx, 50)
                self.state = 555
                self.rsetStmt()
                pass

            elif la_ == 51:
                self.enterOuterAlt(localctx, 51)
                self.state = 556
                self.savepictureStmt()
                pass

            elif la_ == 52:
                self.enterOuterAlt(localctx, 52)
                self.state = 557
                self.saveSettingStmt()
                pass

            elif la_ == 53:
                self.enterOuterAlt(localctx, 53)
                self.state = 558
                self.seekStmt()
                pass

            elif la_ == 54:
                self.enterOuterAlt(localctx, 54)
                self.state = 559
                self.selectCaseStmt()
                pass

            elif la_ == 55:
                self.enterOuterAlt(localctx, 55)
                self.state = 560
                self.sendkeysStmt()
                pass

            elif la_ == 56:
                self.enterOuterAlt(localctx, 56)
                self.state = 561
                self.setattrStmt()
                pass

            elif la_ == 57:
                self.enterOuterAlt(localctx, 57)
                self.state = 562
                self.setStmt()
                pass

            elif la_ == 58:
                self.enterOuterAlt(localctx, 58)
                self.state = 563
                self.stopStmt()
                pass

            elif la_ == 59:
                self.enterOuterAlt(localctx, 59)
                self.state = 564
                self.timeStmt()
                pass

            elif la_ == 60:
                self.enterOuterAlt(localctx, 60)
                self.state = 565
                self.unloadStmt()
                pass

            elif la_ == 61:
                self.enterOuterAlt(localctx, 61)
                self.state = 566
                self.unlockStmt()
                pass

            elif la_ == 62:
                self.enterOuterAlt(localctx, 62)
                self.state = 567
                self.variableStmt()
                pass

            elif la_ == 63:
                self.enterOuterAlt(localctx, 63)
                self.state = 568
                self.whileWendStmt()
                pass

            elif la_ == 64:
                self.enterOuterAlt(localctx, 64)
                self.state = 569
                self.widthStmt()
                pass

            elif la_ == 65:
                self.enterOuterAlt(localctx, 65)
                self.state = 570
                self.withStmt()
                pass

            elif la_ == 66:
                self.enterOuterAlt(localctx, 66)
                self.state = 571
                self.writeStmt()
                pass

            elif la_ == 67:
                self.enterOuterAlt(localctx, 67)
                self.state = 572
                self.implicitCallStmt_InBlock()
                pass

            elif la_ == 68:
                self.enterOuterAlt(localctx, 68)
                self.state = 573
                self.implicitCallStmt_InStmt()
                pass


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


    class AppactivateStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def APPACTIVATE(self):
            return self.getToken(vbaParser.APPACTIVATE, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_appactivateStmt

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

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




    def appactivateStmt(self):

        localctx = vbaParser.AppactivateStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_appactivateStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(vbaParser.APPACTIVATE)
            self.state = 577
            self.match(vbaParser.WS)
            self.state = 578
            self.valueStmt(0)
            self.state = 587
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 580
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 579
                    self.match(vbaParser.WS)


                self.state = 582
                self.match(vbaParser.T__0)
                self.state = 584
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 583
                    self.match(vbaParser.WS)


                self.state = 586
                self.valueStmt(0)


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


    class BeepStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BEEP(self):
            return self.getToken(vbaParser.BEEP, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_beepStmt

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

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




    def beepStmt(self):

        localctx = vbaParser.BeepStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_beepStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 589
            self.match(vbaParser.BEEP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ChdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHDIR(self):
            return self.getToken(vbaParser.CHDIR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_chdirStmt

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

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




    def chdirStmt(self):

        localctx = vbaParser.ChdirStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_chdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 591
            self.match(vbaParser.CHDIR)
            self.state = 592
            self.match(vbaParser.WS)
            self.state = 593
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ChdriveStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHDRIVE(self):
            return self.getToken(vbaParser.CHDRIVE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_chdriveStmt

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

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




    def chdriveStmt(self):

        localctx = vbaParser.ChdriveStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_chdriveStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 595
            self.match(vbaParser.CHDRIVE)
            self.state = 596
            self.match(vbaParser.WS)
            self.state = 597
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CloseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CLOSE(self):
            return self.getToken(vbaParser.CLOSE, 0)

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

        def fileNumber(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.FileNumberContext)
            else:
                return self.getTypedRuleContext(vbaParser.FileNumberContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_closeStmt

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

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




    def closeStmt(self):

        localctx = vbaParser.CloseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_closeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 599
            self.match(vbaParser.CLOSE)
            self.state = 615
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 600
                self.match(vbaParser.WS)
                self.state = 601
                self.fileNumber()
                self.state = 612
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,42,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 603
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 602
                            self.match(vbaParser.WS)


                        self.state = 605
                        self.match(vbaParser.T__0)
                        self.state = 607
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 606
                            self.match(vbaParser.WS)


                        self.state = 609
                        self.fileNumber() 
                    self.state = 614
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,42,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 ConstStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONST(self):
            return self.getToken(vbaParser.CONST, 0)

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

        def constSubStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ConstSubStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ConstSubStmtContext,i)


        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_constStmt

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

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




    def constStmt(self):

        localctx = vbaParser.ConstStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_constStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 617
                self.visibility()
                self.state = 618
                self.match(vbaParser.WS)


            self.state = 622
            self.match(vbaParser.CONST)
            self.state = 623
            self.match(vbaParser.WS)
            self.state = 624
            self.constSubStmt()
            self.state = 635
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 626
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 625
                        self.match(vbaParser.WS)


                    self.state = 628
                    self.match(vbaParser.T__0)
                    self.state = 630
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 629
                        self.match(vbaParser.WS)


                    self.state = 632
                    self.constSubStmt() 
                self.state = 637
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,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 ConstSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_constSubStmt

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

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




    def constSubStmt(self):

        localctx = vbaParser.ConstSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_constSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 638
            self.ambiguousIdentifier()
            self.state = 640
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 639
                self.typeHint()


            self.state = 644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.state = 642
                self.match(vbaParser.WS)
                self.state = 643
                self.asTypeClause()


            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 646
                self.match(vbaParser.WS)


            self.state = 649
            self.match(vbaParser.EQ)
            self.state = 651
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 650
                self.match(vbaParser.WS)


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


    class DateStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATE(self):
            return self.getToken(vbaParser.DATE, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_dateStmt

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

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




    def dateStmt(self):

        localctx = vbaParser.DateStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_dateStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 655
            self.match(vbaParser.DATE)
            self.state = 657
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 656
                self.match(vbaParser.WS)


            self.state = 659
            self.match(vbaParser.EQ)
            self.state = 661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 660
                self.match(vbaParser.WS)


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


    class DeclareStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECLARE(self):
            return self.getToken(vbaParser.DECLARE, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def LIB(self):
            return self.getToken(vbaParser.LIB, 0)

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

        def SUB(self):
            return self.getToken(vbaParser.SUB, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def PTRSAFE(self):
            return self.getToken(vbaParser.PTRSAFE, 0)

        def typeHint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.TypeHintContext)
            else:
                return self.getTypedRuleContext(vbaParser.TypeHintContext,i)


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

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def FUNCTION(self):
            return self.getToken(vbaParser.FUNCTION, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_declareStmt

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

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




    def declareStmt(self):

        localctx = vbaParser.DeclareStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_declareStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 665
                self.visibility()
                self.state = 666
                self.match(vbaParser.WS)


            self.state = 670
            self.match(vbaParser.DECLARE)
            self.state = 671
            self.match(vbaParser.WS)
            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.PTRSAFE:
                self.state = 672
                self.match(vbaParser.PTRSAFE)
                self.state = 673
                self.match(vbaParser.WS)


            self.state = 681
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.FUNCTION]:
                self.state = 676
                self.match(vbaParser.FUNCTION)
                self.state = 678
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                    self.state = 677
                    self.typeHint()


                pass
            elif token in [vbaParser.SUB]:
                self.state = 680
                self.match(vbaParser.SUB)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 683
            self.match(vbaParser.WS)
            self.state = 684
            self.ambiguousIdentifier()
            self.state = 686
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 685
                self.typeHint()


            self.state = 688
            self.match(vbaParser.WS)
            self.state = 689
            self.match(vbaParser.LIB)
            self.state = 690
            self.match(vbaParser.WS)
            self.state = 691
            self.match(vbaParser.STRINGLITERAL)
            self.state = 696
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 692
                self.match(vbaParser.WS)
                self.state = 693
                self.match(vbaParser.ALIAS)
                self.state = 694
                self.match(vbaParser.WS)
                self.state = 695
                self.match(vbaParser.STRINGLITERAL)


            self.state = 702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 698
                    self.match(vbaParser.WS)


                self.state = 701
                self.argList()


            self.state = 706
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.state = 704
                self.match(vbaParser.WS)
                self.state = 705
                self.asTypeClause()


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


    class DeftypeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def letterrange(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.LetterrangeContext)
            else:
                return self.getTypedRuleContext(vbaParser.LetterrangeContext,i)


        def DEFBOOL(self):
            return self.getToken(vbaParser.DEFBOOL, 0)

        def DEFBYTE(self):
            return self.getToken(vbaParser.DEFBYTE, 0)

        def DEFINT(self):
            return self.getToken(vbaParser.DEFINT, 0)

        def DEFLNG(self):
            return self.getToken(vbaParser.DEFLNG, 0)

        def DEFCUR(self):
            return self.getToken(vbaParser.DEFCUR, 0)

        def DEFSNG(self):
            return self.getToken(vbaParser.DEFSNG, 0)

        def DEFDBL(self):
            return self.getToken(vbaParser.DEFDBL, 0)

        def DEFDEC(self):
            return self.getToken(vbaParser.DEFDEC, 0)

        def DEFDATE(self):
            return self.getToken(vbaParser.DEFDATE, 0)

        def DEFSTR(self):
            return self.getToken(vbaParser.DEFSTR, 0)

        def DEFOBJ(self):
            return self.getToken(vbaParser.DEFOBJ, 0)

        def DEFVAR(self):
            return self.getToken(vbaParser.DEFVAR, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_deftypeStmt

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

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




    def deftypeStmt(self):

        localctx = vbaParser.DeftypeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_deftypeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 708
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 709
            self.match(vbaParser.WS)
            self.state = 710
            self.letterrange()
            self.state = 721
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 712
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 711
                        self.match(vbaParser.WS)


                    self.state = 714
                    self.match(vbaParser.T__0)
                    self.state = 716
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 715
                        self.match(vbaParser.WS)


                    self.state = 718
                    self.letterrange() 
                self.state = 723
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,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 DeleteSettingStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DELETESETTING(self):
            return self.getToken(vbaParser.DELETESETTING, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_deleteSettingStmt

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

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




    def deleteSettingStmt(self):

        localctx = vbaParser.DeleteSettingStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_deleteSettingStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 724
            self.match(vbaParser.DELETESETTING)
            self.state = 725
            self.match(vbaParser.WS)
            self.state = 726
            self.valueStmt(0)
            self.state = 728
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 727
                self.match(vbaParser.WS)


            self.state = 730
            self.match(vbaParser.T__0)
            self.state = 732
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 731
                self.match(vbaParser.WS)


            self.state = 734
            self.valueStmt(0)
            self.state = 743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.state = 736
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 735
                    self.match(vbaParser.WS)


                self.state = 738
                self.match(vbaParser.T__0)
                self.state = 740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 739
                    self.match(vbaParser.WS)


                self.state = 742
                self.valueStmt(0)


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


    class DoLoopStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DO(self):
            return self.getToken(vbaParser.DO, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def LOOP(self):
            return self.getToken(vbaParser.LOOP, 0)

        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def WHILE(self):
            return self.getToken(vbaParser.WHILE, 0)

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

        def getRuleIndex(self):
            return vbaParser.RULE_doLoopStmt

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

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




    def doLoopStmt(self):

        localctx = vbaParser.DoLoopStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_doLoopStmt)
        self._la = 0 # Token type
        try:
            self.state = 772
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 745
                self.match(vbaParser.DO)
                self.state = 746
                self.endOfStatement()
                self.state = 748
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
                if la_ == 1:
                    self.state = 747
                    self.block()


                self.state = 750
                self.match(vbaParser.LOOP)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 752
                self.match(vbaParser.DO)
                self.state = 753
                self.match(vbaParser.WS)
                self.state = 754
                _la = self._input.LA(1)
                if not(_la==vbaParser.UNTIL or _la==vbaParser.WHILE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 755
                self.match(vbaParser.WS)
                self.state = 756
                self.valueStmt(0)
                self.state = 757
                self.endOfStatement()
                self.state = 759
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
                if la_ == 1:
                    self.state = 758
                    self.block()


                self.state = 761
                self.match(vbaParser.LOOP)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 763
                self.match(vbaParser.DO)
                self.state = 764
                self.endOfStatement()
                self.state = 765
                self.block()
                self.state = 766
                self.match(vbaParser.LOOP)
                self.state = 767
                self.match(vbaParser.WS)
                self.state = 768
                _la = self._input.LA(1)
                if not(_la==vbaParser.UNTIL or _la==vbaParser.WHILE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 769
                self.match(vbaParser.WS)
                self.state = 770
                self.valueStmt(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 EndStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_endStmt

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

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




    def endStmt(self):

        localctx = vbaParser.EndStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_endStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 774
            self.match(vbaParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumerationStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENUM(self):
            return self.getToken(vbaParser.ENUM, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_ENUM(self):
            return self.getToken(vbaParser.END_ENUM, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def enumerationStmt_Constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EnumerationStmt_ConstantContext)
            else:
                return self.getTypedRuleContext(vbaParser.EnumerationStmt_ConstantContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_enumerationStmt

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

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




    def enumerationStmt(self):

        localctx = vbaParser.EnumerationStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_enumerationStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 776
                self.visibility()
                self.state = 777
                self.match(vbaParser.WS)


            self.state = 781
            self.match(vbaParser.ENUM)
            self.state = 782
            self.match(vbaParser.WS)
            self.state = 783
            self.ambiguousIdentifier()
            self.state = 784
            self.endOfStatement()
            self.state = 788
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 785
                self.enumerationStmt_Constant()
                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 791
            self.match(vbaParser.END_ENUM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumerationStmt_ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_enumerationStmt_Constant

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

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




    def enumerationStmt_Constant(self):

        localctx = vbaParser.EnumerationStmt_ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_enumerationStmt_Constant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 793
            self.ambiguousIdentifier()
            self.state = 802
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 795
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 794
                    self.match(vbaParser.WS)


                self.state = 797
                self.match(vbaParser.EQ)
                self.state = 799
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 798
                    self.match(vbaParser.WS)


                self.state = 801
                self.valueStmt(0)


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


    class EraseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ERASE(self):
            return self.getToken(vbaParser.ERASE, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_eraseStmt

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

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




    def eraseStmt(self):

        localctx = vbaParser.EraseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_eraseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 806
            self.match(vbaParser.ERASE)
            self.state = 807
            self.match(vbaParser.WS)
            self.state = 808
            self.valueStmt(0)
            self.state = 816
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
            while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1+1:
                    self.state = 809
                    self.match(vbaParser.T__0)
                    self.state = 811
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 810
                        self.match(vbaParser.WS)


                    self.state = 813
                    self.valueStmt(0) 
                self.state = 818
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,80,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 ErrorStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ERROR(self):
            return self.getToken(vbaParser.ERROR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_errorStmt

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

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




    def errorStmt(self):

        localctx = vbaParser.ErrorStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_errorStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 819
            self.match(vbaParser.ERROR)
            self.state = 820
            self.match(vbaParser.WS)
            self.state = 821
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EVENT(self):
            return self.getToken(vbaParser.EVENT, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_eventStmt

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

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




    def eventStmt(self):

        localctx = vbaParser.EventStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_eventStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 823
                self.visibility()
                self.state = 824
                self.match(vbaParser.WS)


            self.state = 828
            self.match(vbaParser.EVENT)
            self.state = 829
            self.match(vbaParser.WS)
            self.state = 830
            self.ambiguousIdentifier()
            self.state = 832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 831
                self.match(vbaParser.WS)


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


    class ExitStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EXIT_DO(self):
            return self.getToken(vbaParser.EXIT_DO, 0)

        def EXIT_FOR(self):
            return self.getToken(vbaParser.EXIT_FOR, 0)

        def EXIT_FUNCTION(self):
            return self.getToken(vbaParser.EXIT_FUNCTION, 0)

        def EXIT_PROPERTY(self):
            return self.getToken(vbaParser.EXIT_PROPERTY, 0)

        def EXIT_SUB(self):
            return self.getToken(vbaParser.EXIT_SUB, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_exitStmt

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

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




    def exitStmt(self):

        localctx = vbaParser.ExitStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_exitStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 836
            _la = self._input.LA(1)
            if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (vbaParser.EXIT_DO - 68)) | (1 << (vbaParser.EXIT_FOR - 68)) | (1 << (vbaParser.EXIT_FUNCTION - 68)) | (1 << (vbaParser.EXIT_PROPERTY - 68)) | (1 << (vbaParser.EXIT_SUB - 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 FilecopyStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FILECOPY(self):
            return self.getToken(vbaParser.FILECOPY, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_filecopyStmt

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

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




    def filecopyStmt(self):

        localctx = vbaParser.FilecopyStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_filecopyStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 838
            self.match(vbaParser.FILECOPY)
            self.state = 839
            self.match(vbaParser.WS)
            self.state = 840
            self.valueStmt(0)
            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 841
                self.match(vbaParser.WS)


            self.state = 844
            self.match(vbaParser.T__0)
            self.state = 846
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 845
                self.match(vbaParser.WS)


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


    class ForEachStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def EACH(self):
            return self.getToken(vbaParser.EACH, 0)

        def ambiguousIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousIdentifierContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,i)


        def IN(self):
            return self.getToken(vbaParser.IN, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_forEachStmt

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

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




    def forEachStmt(self):

        localctx = vbaParser.ForEachStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_forEachStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 850
            self.match(vbaParser.FOR)
            self.state = 851
            self.match(vbaParser.WS)
            self.state = 852
            self.match(vbaParser.EACH)
            self.state = 853
            self.match(vbaParser.WS)
            self.state = 854
            self.ambiguousIdentifier()
            self.state = 856
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 855
                self.typeHint()


            self.state = 858
            self.match(vbaParser.WS)
            self.state = 859
            self.match(vbaParser.IN)
            self.state = 860
            self.match(vbaParser.WS)
            self.state = 861
            self.valueStmt(0)
            self.state = 862
            self.endOfStatement()
            self.state = 864
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 863
                self.block()


            self.state = 866
            self.match(vbaParser.NEXT)
            self.state = 869
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 867
                self.match(vbaParser.WS)
                self.state = 868
                self.ambiguousIdentifier()


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


    class ForNextStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def ambiguousIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousIdentifierContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,i)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


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

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def STEP(self):
            return self.getToken(vbaParser.STEP, 0)

        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_forNextStmt

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

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




    def forNextStmt(self):

        localctx = vbaParser.ForNextStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_forNextStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 871
            self.match(vbaParser.FOR)
            self.state = 872
            self.match(vbaParser.WS)
            self.state = 873
            self.ambiguousIdentifier()
            self.state = 875
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 874
                self.typeHint()


            self.state = 879
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.state = 877
                self.match(vbaParser.WS)
                self.state = 878
                self.asTypeClause()


            self.state = 882
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 881
                self.match(vbaParser.WS)


            self.state = 884
            self.match(vbaParser.EQ)
            self.state = 886
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 885
                self.match(vbaParser.WS)


            self.state = 888
            self.valueStmt(0)
            self.state = 889
            self.match(vbaParser.WS)
            self.state = 890
            self.match(vbaParser.TO)
            self.state = 891
            self.match(vbaParser.WS)
            self.state = 892
            self.valueStmt(0)
            self.state = 897
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.state = 893
                self.match(vbaParser.WS)
                self.state = 894
                self.match(vbaParser.STEP)
                self.state = 895
                self.match(vbaParser.WS)
                self.state = 896
                self.valueStmt(0)


            self.state = 899
            self.endOfStatement()
            self.state = 901
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 900
                self.block()


            self.state = 903
            self.match(vbaParser.NEXT)
            self.state = 906
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.state = 904
                self.match(vbaParser.WS)
                self.state = 905
                self.ambiguousIdentifier()


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


    class FunctionStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNCTION(self):
            return self.getToken(vbaParser.FUNCTION, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_FUNCTION(self):
            return self.getToken(vbaParser.END_FUNCTION, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


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

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_functionStmt

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

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




    def functionStmt(self):

        localctx = vbaParser.FunctionStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_functionStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 911
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 908
                self.visibility()
                self.state = 909
                self.match(vbaParser.WS)


            self.state = 915
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.STATIC:
                self.state = 913
                self.match(vbaParser.STATIC)
                self.state = 914
                self.match(vbaParser.WS)


            self.state = 917
            self.match(vbaParser.FUNCTION)
            self.state = 919
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 918
                self.match(vbaParser.WS)


            self.state = 921
            self.ambiguousIdentifier()
            self.state = 923
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
            if la_ == 1:
                self.state = 922
                self.typeHint()


            self.state = 929
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.state = 926
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 925
                    self.match(vbaParser.WS)


                self.state = 928
                self.argList()


            self.state = 935
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
            if la_ == 1:
                self.state = 932
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 931
                    self.match(vbaParser.WS)


                self.state = 934
                self.asTypeClause()


            self.state = 937
            self.endOfStatement()
            self.state = 939
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 938
                self.block()


            self.state = 941
            self.match(vbaParser.END_FUNCTION)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GET(self):
            return self.getToken(vbaParser.GET, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_getStmt

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

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




    def getStmt(self):

        localctx = vbaParser.GetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_getStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 943
            self.match(vbaParser.GET)
            self.state = 944
            self.match(vbaParser.WS)
            self.state = 945
            self.fileNumber()
            self.state = 947
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 946
                self.match(vbaParser.WS)


            self.state = 949
            self.match(vbaParser.T__0)
            self.state = 951
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 950
                self.match(vbaParser.WS)


            self.state = 954
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (vbaParser.LPAREN - 193)) | (1 << (vbaParser.MINUS - 193)) | (1 << (vbaParser.PLUS - 193)) | (1 << (vbaParser.STRINGLITERAL - 193)) | (1 << (vbaParser.OCTLITERAL - 193)) | (1 << (vbaParser.HEXLITERAL - 193)) | (1 << (vbaParser.SHORTLITERAL - 193)) | (1 << (vbaParser.INTEGERLITERAL - 193)) | (1 << (vbaParser.DOUBLELITERAL - 193)) | (1 << (vbaParser.DATELITERAL - 193)) | (1 << (vbaParser.IDENTIFIER - 193)))) != 0):
                self.state = 953
                self.valueStmt(0)


            self.state = 957
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 956
                self.match(vbaParser.WS)


            self.state = 959
            self.match(vbaParser.T__0)
            self.state = 961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 960
                self.match(vbaParser.WS)


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


    class GoSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GOSUB(self):
            return self.getToken(vbaParser.GOSUB, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_goSubStmt

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

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




    def goSubStmt(self):

        localctx = vbaParser.GoSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_goSubStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 965
            self.match(vbaParser.GOSUB)
            self.state = 966
            self.match(vbaParser.WS)
            self.state = 967
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GoToStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_goToStmt

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

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




    def goToStmt(self):

        localctx = vbaParser.GoToStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_goToStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 969
            self.match(vbaParser.GOTO)
            self.state = 970
            self.match(vbaParser.WS)
            self.state = 971
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfThenElseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_ifThenElseStmt

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



    class BlockIfThenElseContext(IfThenElseStmtContext):

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

        def ifBlockStmt(self):
            return self.getTypedRuleContext(vbaParser.IfBlockStmtContext,0)

        def END_IF(self):
            return self.getToken(vbaParser.END_IF, 0)
        def ifElseIfBlockStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.IfElseIfBlockStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.IfElseIfBlockStmtContext,i)

        def ifElseBlockStmt(self):
            return self.getTypedRuleContext(vbaParser.IfElseBlockStmtContext,0)


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

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


    class InlineIfThenElseContext(IfThenElseStmtContext):

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

        def IF(self):
            return self.getToken(vbaParser.IF, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)
        def ifConditionStmt(self):
            return self.getTypedRuleContext(vbaParser.IfConditionStmtContext,0)

        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)
        def blockStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.BlockStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.BlockStmtContext,i)

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

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

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



    def ifThenElseStmt(self):

        localctx = vbaParser.IfThenElseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_ifThenElseStmt)
        self._la = 0 # Token type
        try:
            self.state = 998
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
            if la_ == 1:
                localctx = vbaParser.InlineIfThenElseContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 973
                self.match(vbaParser.IF)
                self.state = 974
                self.match(vbaParser.WS)
                self.state = 975
                self.ifConditionStmt()
                self.state = 976
                self.match(vbaParser.WS)
                self.state = 977
                self.match(vbaParser.THEN)
                self.state = 978
                self.match(vbaParser.WS)
                self.state = 979
                self.blockStmt()
                self.state = 984
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                if la_ == 1:
                    self.state = 980
                    self.match(vbaParser.WS)
                    self.state = 981
                    self.match(vbaParser.ELSE)
                    self.state = 982
                    self.match(vbaParser.WS)
                    self.state = 983
                    self.blockStmt()


                pass

            elif la_ == 2:
                localctx = vbaParser.BlockIfThenElseContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 986
                self.ifBlockStmt()
                self.state = 990
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vbaParser.ELSEIF:
                    self.state = 987
                    self.ifElseIfBlockStmt()
                    self.state = 992
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 994
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.ELSE:
                    self.state = 993
                    self.ifElseBlockStmt()


                self.state = 996
                self.match(vbaParser.END_IF)
                pass


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


    class IfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IF(self):
            return self.getToken(vbaParser.IF, 0)

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

        def ifConditionStmt(self):
            return self.getTypedRuleContext(vbaParser.IfConditionStmtContext,0)


        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_ifBlockStmt

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

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




    def ifBlockStmt(self):

        localctx = vbaParser.IfBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_ifBlockStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1000
            self.match(vbaParser.IF)
            self.state = 1001
            self.match(vbaParser.WS)
            self.state = 1002
            self.ifConditionStmt()
            self.state = 1003
            self.match(vbaParser.WS)
            self.state = 1004
            self.match(vbaParser.THEN)
            self.state = 1005
            self.endOfStatement()
            self.state = 1007
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.state = 1006
                self.block()


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


    class IfConditionStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_ifConditionStmt

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

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




    def ifConditionStmt(self):

        localctx = vbaParser.IfConditionStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_ifConditionStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1009
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfElseIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ELSEIF(self):
            return self.getToken(vbaParser.ELSEIF, 0)

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

        def ifConditionStmt(self):
            return self.getTypedRuleContext(vbaParser.IfConditionStmtContext,0)


        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_ifElseIfBlockStmt

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

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




    def ifElseIfBlockStmt(self):

        localctx = vbaParser.IfElseIfBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_ifElseIfBlockStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1011
            self.match(vbaParser.ELSEIF)
            self.state = 1012
            self.match(vbaParser.WS)
            self.state = 1013
            self.ifConditionStmt()
            self.state = 1014
            self.match(vbaParser.WS)
            self.state = 1015
            self.match(vbaParser.THEN)
            self.state = 1016
            self.endOfStatement()
            self.state = 1018
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 1017
                self.block()


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


    class IfElseBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_ifElseBlockStmt

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

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




    def ifElseBlockStmt(self):

        localctx = vbaParser.IfElseBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_ifElseBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            self.match(vbaParser.ELSE)
            self.state = 1021
            self.endOfStatement()
            self.state = 1023
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1022
                self.block()


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


    class ImplementsStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IMPLEMENTS(self):
            return self.getToken(vbaParser.IMPLEMENTS, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_implementsStmt

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

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




    def implementsStmt(self):

        localctx = vbaParser.ImplementsStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_implementsStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1025
            self.match(vbaParser.IMPLEMENTS)
            self.state = 1026
            self.match(vbaParser.WS)
            self.state = 1027
            self.ambiguousIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InputStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INPUT(self):
            return self.getToken(vbaParser.INPUT, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_inputStmt

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

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




    def inputStmt(self):

        localctx = vbaParser.InputStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_inputStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1029
            self.match(vbaParser.INPUT)
            self.state = 1030
            self.match(vbaParser.WS)
            self.state = 1031
            self.fileNumber()
            self.state = 1040 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1033
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1032
                        self.match(vbaParser.WS)


                    self.state = 1035
                    self.match(vbaParser.T__0)
                    self.state = 1037
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1036
                        self.match(vbaParser.WS)


                    self.state = 1039
                    self.valueStmt(0)

                else:
                    raise NoViableAltException(self)
                self.state = 1042 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,118,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 KillStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def KILL(self):
            return self.getToken(vbaParser.KILL, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_killStmt

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

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




    def killStmt(self):

        localctx = vbaParser.KillStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_killStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            self.match(vbaParser.KILL)
            self.state = 1045
            self.match(vbaParser.WS)
            self.state = 1046
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def PLUS_EQ(self):
            return self.getToken(vbaParser.PLUS_EQ, 0)

        def MINUS_EQ(self):
            return self.getToken(vbaParser.MINUS_EQ, 0)

        def LET(self):
            return self.getToken(vbaParser.LET, 0)

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

        def getRuleIndex(self):
            return vbaParser.RULE_letStmt

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

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




    def letStmt(self):

        localctx = vbaParser.LetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_letStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1050
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.state = 1048
                self.match(vbaParser.LET)
                self.state = 1049
                self.match(vbaParser.WS)


            self.state = 1052
            self.implicitCallStmt_InStmt()
            self.state = 1054
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1053
                self.match(vbaParser.WS)


            self.state = 1056
            _la = self._input.LA(1)
            if not(((((_la - 189)) & ~0x3f) == 0 and ((1 << (_la - 189)) & ((1 << (vbaParser.EQ - 189)) | (1 << (vbaParser.MINUS_EQ - 189)) | (1 << (vbaParser.PLUS_EQ - 189)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1058
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1057
                self.match(vbaParser.WS)


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


    class LineInputStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LINE_INPUT(self):
            return self.getToken(vbaParser.LINE_INPUT, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_lineInputStmt

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

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




    def lineInputStmt(self):

        localctx = vbaParser.LineInputStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_lineInputStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1062
            self.match(vbaParser.LINE_INPUT)
            self.state = 1063
            self.match(vbaParser.WS)
            self.state = 1064
            self.fileNumber()
            self.state = 1066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1065
                self.match(vbaParser.WS)


            self.state = 1068
            self.match(vbaParser.T__0)
            self.state = 1070
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1069
                self.match(vbaParser.WS)


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


    class LoadStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOAD(self):
            return self.getToken(vbaParser.LOAD, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_loadStmt

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

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




    def loadStmt(self):

        localctx = vbaParser.LoadStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_loadStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1074
            self.match(vbaParser.LOAD)
            self.state = 1075
            self.match(vbaParser.WS)
            self.state = 1076
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOCK(self):
            return self.getToken(vbaParser.LOCK, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_lockStmt

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

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




    def lockStmt(self):

        localctx = vbaParser.LockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_lockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078
            self.match(vbaParser.LOCK)
            self.state = 1079
            self.match(vbaParser.WS)
            self.state = 1080
            self.valueStmt(0)
            self.state = 1095
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.state = 1082
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1081
                    self.match(vbaParser.WS)


                self.state = 1084
                self.match(vbaParser.T__0)
                self.state = 1086
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1085
                    self.match(vbaParser.WS)


                self.state = 1088
                self.valueStmt(0)
                self.state = 1093
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                if la_ == 1:
                    self.state = 1089
                    self.match(vbaParser.WS)
                    self.state = 1090
                    self.match(vbaParser.TO)
                    self.state = 1091
                    self.match(vbaParser.WS)
                    self.state = 1092
                    self.valueStmt(0)




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


    class LsetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LSET(self):
            return self.getToken(vbaParser.LSET, 0)

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_lsetStmt

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

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




    def lsetStmt(self):

        localctx = vbaParser.LsetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_lsetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            self.match(vbaParser.LSET)
            self.state = 1098
            self.match(vbaParser.WS)
            self.state = 1099
            self.implicitCallStmt_InStmt()
            self.state = 1101
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1100
                self.match(vbaParser.WS)


            self.state = 1103
            self.match(vbaParser.EQ)
            self.state = 1105
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1104
                self.match(vbaParser.WS)


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


    class MacroConstStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MACRO_CONST(self):
            return self.getToken(vbaParser.MACRO_CONST, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_macroConstStmt

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

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




    def macroConstStmt(self):

        localctx = vbaParser.MacroConstStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_macroConstStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1109
            self.match(vbaParser.MACRO_CONST)
            self.state = 1111
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1110
                self.match(vbaParser.WS)


            self.state = 1113
            self.ambiguousIdentifier()
            self.state = 1115
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1114
                self.match(vbaParser.WS)


            self.state = 1117
            self.match(vbaParser.EQ)
            self.state = 1119
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1118
                self.match(vbaParser.WS)


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


    class MacroIfThenElseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def macroIfBlockStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroIfBlockStmtContext,0)


        def MACRO_END_IF(self):
            return self.getToken(vbaParser.MACRO_END_IF, 0)

        def macroElseIfBlockStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.MacroElseIfBlockStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.MacroElseIfBlockStmtContext,i)


        def macroElseBlockStmt(self):
            return self.getTypedRuleContext(vbaParser.MacroElseBlockStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_macroIfThenElseStmt

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

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




    def macroIfThenElseStmt(self):

        localctx = vbaParser.MacroIfThenElseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_macroIfThenElseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1123
            self.macroIfBlockStmt()
            self.state = 1127
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vbaParser.MACRO_ELSEIF:
                self.state = 1124
                self.macroElseIfBlockStmt()
                self.state = 1129
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.MACRO_ELSE:
                self.state = 1130
                self.macroElseBlockStmt()


            self.state = 1133
            self.match(vbaParser.MACRO_END_IF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MacroIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MACRO_IF(self):
            return self.getToken(vbaParser.MACRO_IF, 0)

        def ifConditionStmt(self):
            return self.getTypedRuleContext(vbaParser.IfConditionStmtContext,0)


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

        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def moduleDeclarations(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleDeclarationsContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleDeclarationsContext,i)


        def moduleBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleBodyContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleBodyContext,i)


        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.BlockContext)
            else:
                return self.getTypedRuleContext(vbaParser.BlockContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_macroIfBlockStmt

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

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




    def macroIfBlockStmt(self):

        localctx = vbaParser.MacroIfBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_macroIfBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1135
            self.match(vbaParser.MACRO_IF)
            self.state = 1137
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1136
                self.match(vbaParser.WS)


            self.state = 1139
            self.ifConditionStmt()
            self.state = 1140
            self.match(vbaParser.WS)
            self.state = 1141
            self.match(vbaParser.THEN)
            self.state = 1142
            self.endOfStatement()
            self.state = 1148
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OPTION_BASE - 64)) | (1 << (vbaParser.OPTION_EXPLICIT - 64)) | (1 << (vbaParser.OPTION_COMPARE - 64)) | (1 << (vbaParser.OPTION_PRIVATE_MODULE - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PROPERTY_GET - 128)) | (1 << (vbaParser.PROPERTY_LET - 128)) | (1 << (vbaParser.PROPERTY_SET - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.COMMENT or _la==vbaParser.IDENTIFIER:
                self.state = 1146
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                if la_ == 1:
                    self.state = 1143
                    self.moduleDeclarations()
                    pass

                elif la_ == 2:
                    self.state = 1144
                    self.moduleBody()
                    pass

                elif la_ == 3:
                    self.state = 1145
                    self.block()
                    pass


                self.state = 1150
                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 MacroElseIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MACRO_ELSEIF(self):
            return self.getToken(vbaParser.MACRO_ELSEIF, 0)

        def ifConditionStmt(self):
            return self.getTypedRuleContext(vbaParser.IfConditionStmtContext,0)


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

        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def moduleDeclarations(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleDeclarationsContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleDeclarationsContext,i)


        def moduleBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleBodyContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleBodyContext,i)


        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.BlockContext)
            else:
                return self.getTypedRuleContext(vbaParser.BlockContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_macroElseIfBlockStmt

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

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




    def macroElseIfBlockStmt(self):

        localctx = vbaParser.MacroElseIfBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_macroElseIfBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1151
            self.match(vbaParser.MACRO_ELSEIF)
            self.state = 1153
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1152
                self.match(vbaParser.WS)


            self.state = 1155
            self.ifConditionStmt()
            self.state = 1156
            self.match(vbaParser.WS)
            self.state = 1157
            self.match(vbaParser.THEN)
            self.state = 1158
            self.endOfStatement()
            self.state = 1164
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OPTION_BASE - 64)) | (1 << (vbaParser.OPTION_EXPLICIT - 64)) | (1 << (vbaParser.OPTION_COMPARE - 64)) | (1 << (vbaParser.OPTION_PRIVATE_MODULE - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PROPERTY_GET - 128)) | (1 << (vbaParser.PROPERTY_LET - 128)) | (1 << (vbaParser.PROPERTY_SET - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.COMMENT or _la==vbaParser.IDENTIFIER:
                self.state = 1162
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                if la_ == 1:
                    self.state = 1159
                    self.moduleDeclarations()
                    pass

                elif la_ == 2:
                    self.state = 1160
                    self.moduleBody()
                    pass

                elif la_ == 3:
                    self.state = 1161
                    self.block()
                    pass


                self.state = 1166
                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 MacroElseBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MACRO_ELSE(self):
            return self.getToken(vbaParser.MACRO_ELSE, 0)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def moduleDeclarations(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleDeclarationsContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleDeclarationsContext,i)


        def moduleBody(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ModuleBodyContext)
            else:
                return self.getTypedRuleContext(vbaParser.ModuleBodyContext,i)


        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.BlockContext)
            else:
                return self.getTypedRuleContext(vbaParser.BlockContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_macroElseBlockStmt

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

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




    def macroElseBlockStmt(self):

        localctx = vbaParser.MacroElseBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_macroElseBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1167
            self.match(vbaParser.MACRO_ELSE)
            self.state = 1168
            self.endOfStatement()
            self.state = 1174
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OPTION_BASE - 64)) | (1 << (vbaParser.OPTION_EXPLICIT - 64)) | (1 << (vbaParser.OPTION_COMPARE - 64)) | (1 << (vbaParser.OPTION_PRIVATE_MODULE - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PROPERTY_GET - 128)) | (1 << (vbaParser.PROPERTY_LET - 128)) | (1 << (vbaParser.PROPERTY_SET - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.COMMENT or _la==vbaParser.IDENTIFIER:
                self.state = 1172
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                if la_ == 1:
                    self.state = 1169
                    self.moduleDeclarations()
                    pass

                elif la_ == 2:
                    self.state = 1170
                    self.moduleBody()
                    pass

                elif la_ == 3:
                    self.state = 1171
                    self.block()
                    pass


                self.state = 1176
                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 MidStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MID(self):
            return self.getToken(vbaParser.MID, 0)

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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_midStmt

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

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




    def midStmt(self):

        localctx = vbaParser.MidStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_midStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            self.match(vbaParser.MID)
            self.state = 1179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1178
                self.match(vbaParser.WS)


            self.state = 1181
            self.match(vbaParser.LPAREN)
            self.state = 1183
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1182
                self.match(vbaParser.WS)


            self.state = 1185
            self.argsCall()
            self.state = 1187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1186
                self.match(vbaParser.WS)


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


    class MkdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MKDIR(self):
            return self.getToken(vbaParser.MKDIR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_mkdirStmt

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

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




    def mkdirStmt(self):

        localctx = vbaParser.MkdirStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_mkdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1191
            self.match(vbaParser.MKDIR)
            self.state = 1192
            self.match(vbaParser.WS)
            self.state = 1193
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_nameStmt

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

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




    def nameStmt(self):

        localctx = vbaParser.NameStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_nameStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1195
            self.match(vbaParser.NAME)
            self.state = 1196
            self.match(vbaParser.WS)
            self.state = 1197
            self.valueStmt(0)
            self.state = 1198
            self.match(vbaParser.WS)
            self.state = 1199
            self.match(vbaParser.AS)
            self.state = 1200
            self.match(vbaParser.WS)
            self.state = 1201
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OnErrorStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ON_ERROR(self):
            return self.getToken(vbaParser.ON_ERROR, 0)

        def ON_LOCAL_ERROR(self):
            return self.getToken(vbaParser.ON_LOCAL_ERROR, 0)

        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def RESUME(self):
            return self.getToken(vbaParser.RESUME, 0)

        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onErrorStmt

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

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




    def onErrorStmt(self):

        localctx = vbaParser.OnErrorStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_onErrorStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            _la = self._input.LA(1)
            if not(_la==vbaParser.ON_ERROR or _la==vbaParser.ON_LOCAL_ERROR):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1204
            self.match(vbaParser.WS)
            self.state = 1211
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.GOTO]:
                self.state = 1205
                self.match(vbaParser.GOTO)
                self.state = 1206
                self.match(vbaParser.WS)
                self.state = 1207
                self.valueStmt(0)
                pass
            elif token in [vbaParser.RESUME]:
                self.state = 1208
                self.match(vbaParser.RESUME)
                self.state = 1209
                self.match(vbaParser.WS)
                self.state = 1210
                self.match(vbaParser.NEXT)
                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 OnGoToStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ON(self):
            return self.getToken(vbaParser.ON, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onGoToStmt

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

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




    def onGoToStmt(self):

        localctx = vbaParser.OnGoToStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_onGoToStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1213
            self.match(vbaParser.ON)
            self.state = 1214
            self.match(vbaParser.WS)
            self.state = 1215
            self.valueStmt(0)
            self.state = 1216
            self.match(vbaParser.WS)
            self.state = 1217
            self.match(vbaParser.GOTO)
            self.state = 1218
            self.match(vbaParser.WS)
            self.state = 1219
            self.valueStmt(0)
            self.state = 1230
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,149,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1221
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1220
                        self.match(vbaParser.WS)


                    self.state = 1223
                    self.match(vbaParser.T__0)
                    self.state = 1225
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1224
                        self.match(vbaParser.WS)


                    self.state = 1227
                    self.valueStmt(0) 
                self.state = 1232
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,149,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 OnGoSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ON(self):
            return self.getToken(vbaParser.ON, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def GOSUB(self):
            return self.getToken(vbaParser.GOSUB, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onGoSubStmt

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

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




    def onGoSubStmt(self):

        localctx = vbaParser.OnGoSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_onGoSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1233
            self.match(vbaParser.ON)
            self.state = 1234
            self.match(vbaParser.WS)
            self.state = 1235
            self.valueStmt(0)
            self.state = 1236
            self.match(vbaParser.WS)
            self.state = 1237
            self.match(vbaParser.GOSUB)
            self.state = 1238
            self.match(vbaParser.WS)
            self.state = 1239
            self.valueStmt(0)
            self.state = 1250
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,152,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1241
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1240
                        self.match(vbaParser.WS)


                    self.state = 1243
                    self.match(vbaParser.T__0)
                    self.state = 1245
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1244
                        self.match(vbaParser.WS)


                    self.state = 1247
                    self.valueStmt(0) 
                self.state = 1252
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,152,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 OpenStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


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

        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def APPEND(self):
            return self.getToken(vbaParser.APPEND, 0)

        def BINARY(self):
            return self.getToken(vbaParser.BINARY, 0)

        def INPUT(self):
            return self.getToken(vbaParser.INPUT, 0)

        def OUTPUT(self):
            return self.getToken(vbaParser.OUTPUT, 0)

        def RANDOM(self):
            return self.getToken(vbaParser.RANDOM, 0)

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

        def LEN(self):
            return self.getToken(vbaParser.LEN, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def READ(self):
            return self.getToken(vbaParser.READ, 0)

        def WRITE(self):
            return self.getToken(vbaParser.WRITE, 0)

        def READ_WRITE(self):
            return self.getToken(vbaParser.READ_WRITE, 0)

        def SHARED(self):
            return self.getToken(vbaParser.SHARED, 0)

        def LOCK_READ(self):
            return self.getToken(vbaParser.LOCK_READ, 0)

        def LOCK_WRITE(self):
            return self.getToken(vbaParser.LOCK_WRITE, 0)

        def LOCK_READ_WRITE(self):
            return self.getToken(vbaParser.LOCK_READ_WRITE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_openStmt

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

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




    def openStmt(self):

        localctx = vbaParser.OpenStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_openStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1253
            self.match(vbaParser.OPEN)
            self.state = 1254
            self.match(vbaParser.WS)
            self.state = 1255
            self.valueStmt(0)
            self.state = 1256
            self.match(vbaParser.WS)
            self.state = 1257
            self.match(vbaParser.FOR)
            self.state = 1258
            self.match(vbaParser.WS)
            self.state = 1259
            _la = self._input.LA(1)
            if not(_la==vbaParser.APPEND or _la==vbaParser.BINARY or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & ((1 << (vbaParser.INPUT - 86)) | (1 << (vbaParser.OUTPUT - 86)) | (1 << (vbaParser.RANDOM - 86)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1264
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.state = 1260
                self.match(vbaParser.WS)
                self.state = 1261
                self.match(vbaParser.ACCESS)
                self.state = 1262
                self.match(vbaParser.WS)
                self.state = 1263
                _la = self._input.LA(1)
                if not(((((_la - 142)) & ~0x3f) == 0 and ((1 << (_la - 142)) & ((1 << (vbaParser.READ - 142)) | (1 << (vbaParser.READ_WRITE - 142)) | (1 << (vbaParser.WRITE - 142)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1268
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
            if la_ == 1:
                self.state = 1266
                self.match(vbaParser.WS)
                self.state = 1267
                _la = self._input.LA(1)
                if not(((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & ((1 << (vbaParser.LOCK_READ - 99)) | (1 << (vbaParser.LOCK_WRITE - 99)) | (1 << (vbaParser.LOCK_READ_WRITE - 99)) | (1 << (vbaParser.SHARED - 99)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1270
            self.match(vbaParser.WS)
            self.state = 1271
            self.match(vbaParser.AS)
            self.state = 1272
            self.match(vbaParser.WS)
            self.state = 1273
            self.fileNumber()
            self.state = 1284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
            if la_ == 1:
                self.state = 1274
                self.match(vbaParser.WS)
                self.state = 1275
                self.match(vbaParser.LEN)
                self.state = 1277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1276
                    self.match(vbaParser.WS)


                self.state = 1279
                self.match(vbaParser.EQ)
                self.state = 1281
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1280
                    self.match(vbaParser.WS)


                self.state = 1283
                self.valueStmt(0)


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


    class OutputListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def outputList_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.OutputList_ExpressionContext)
            else:
                return self.getTypedRuleContext(vbaParser.OutputList_ExpressionContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_outputList

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

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




    def outputList(self):

        localctx = vbaParser.OutputListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_outputList)
        self._la = 0 # Token type
        try:
            self.state = 1319
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1286
                self.outputList_Expression()
                self.state = 1299
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1288
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1287
                            self.match(vbaParser.WS)


                        self.state = 1290
                        _la = self._input.LA(1)
                        if not(_la==vbaParser.T__0 or _la==vbaParser.T__1):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1292
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
                        if la_ == 1:
                            self.state = 1291
                            self.match(vbaParser.WS)


                        self.state = 1295
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                        if la_ == 1:
                            self.state = 1294
                            self.outputList_Expression()

                 
                    self.state = 1301
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (vbaParser.LPAREN - 193)) | (1 << (vbaParser.MINUS - 193)) | (1 << (vbaParser.PLUS - 193)) | (1 << (vbaParser.STRINGLITERAL - 193)) | (1 << (vbaParser.OCTLITERAL - 193)) | (1 << (vbaParser.HEXLITERAL - 193)) | (1 << (vbaParser.SHORTLITERAL - 193)) | (1 << (vbaParser.INTEGERLITERAL - 193)) | (1 << (vbaParser.DOUBLELITERAL - 193)) | (1 << (vbaParser.DATELITERAL - 193)) | (1 << (vbaParser.IDENTIFIER - 193)))) != 0):
                    self.state = 1302
                    self.outputList_Expression()


                self.state = 1315 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1306
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1305
                            self.match(vbaParser.WS)


                        self.state = 1308
                        _la = self._input.LA(1)
                        if not(_la==vbaParser.T__0 or _la==vbaParser.T__1):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1310
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                        if la_ == 1:
                            self.state = 1309
                            self.match(vbaParser.WS)


                        self.state = 1313
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                        if la_ == 1:
                            self.state = 1312
                            self.outputList_Expression()



                    else:
                        raise NoViableAltException(self)
                    self.state = 1317 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,166,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 OutputList_ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def SPC(self):
            return self.getToken(vbaParser.SPC, 0)

        def TAB(self):
            return self.getToken(vbaParser.TAB, 0)

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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_outputList_Expression

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

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




    def outputList_Expression(self):

        localctx = vbaParser.OutputList_ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_outputList_Expression)
        self._la = 0 # Token type
        try:
            self.state = 1338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1321
                self.valueStmt(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1322
                _la = self._input.LA(1)
                if not(_la==vbaParser.SPC or _la==vbaParser.TAB):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1336
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1324
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1323
                        self.match(vbaParser.WS)


                    self.state = 1326
                    self.match(vbaParser.LPAREN)
                    self.state = 1328
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                    if la_ == 1:
                        self.state = 1327
                        self.match(vbaParser.WS)


                    self.state = 1330
                    self.argsCall()
                    self.state = 1332
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1331
                        self.match(vbaParser.WS)


                    self.state = 1334
                    self.match(vbaParser.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 PrintStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PRINT(self):
            return self.getToken(vbaParser.PRINT, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def outputList(self):
            return self.getTypedRuleContext(vbaParser.OutputListContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_printStmt

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

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




    def printStmt(self):

        localctx = vbaParser.PrintStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_printStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1340
            self.match(vbaParser.PRINT)
            self.state = 1341
            self.match(vbaParser.WS)
            self.state = 1342
            self.fileNumber()
            self.state = 1344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1343
                self.match(vbaParser.WS)


            self.state = 1346
            self.match(vbaParser.T__0)
            self.state = 1351
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                self.state = 1348
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                if la_ == 1:
                    self.state = 1347
                    self.match(vbaParser.WS)


                self.state = 1350
                self.outputList()


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


    class PropertyGetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PROPERTY_GET(self):
            return self.getToken(vbaParser.PROPERTY_GET, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertyGetStmt

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

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




    def propertyGetStmt(self):

        localctx = vbaParser.PropertyGetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_propertyGetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 1353
                self.visibility()
                self.state = 1354
                self.match(vbaParser.WS)


            self.state = 1360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.STATIC:
                self.state = 1358
                self.match(vbaParser.STATIC)
                self.state = 1359
                self.match(vbaParser.WS)


            self.state = 1362
            self.match(vbaParser.PROPERTY_GET)
            self.state = 1363
            self.match(vbaParser.WS)
            self.state = 1364
            self.ambiguousIdentifier()
            self.state = 1366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 1365
                self.typeHint()


            self.state = 1372
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1369
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1368
                    self.match(vbaParser.WS)


                self.state = 1371
                self.argList()


            self.state = 1376
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1374
                self.match(vbaParser.WS)
                self.state = 1375
                self.asTypeClause()


            self.state = 1378
            self.endOfStatement()
            self.state = 1380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1379
                self.block()


            self.state = 1382
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertySetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PROPERTY_SET(self):
            return self.getToken(vbaParser.PROPERTY_SET, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertySetStmt

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

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




    def propertySetStmt(self):

        localctx = vbaParser.PropertySetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_propertySetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 1384
                self.visibility()
                self.state = 1385
                self.match(vbaParser.WS)


            self.state = 1391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.STATIC:
                self.state = 1389
                self.match(vbaParser.STATIC)
                self.state = 1390
                self.match(vbaParser.WS)


            self.state = 1393
            self.match(vbaParser.PROPERTY_SET)
            self.state = 1394
            self.match(vbaParser.WS)
            self.state = 1395
            self.ambiguousIdentifier()
            self.state = 1400
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
            if la_ == 1:
                self.state = 1397
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1396
                    self.match(vbaParser.WS)


                self.state = 1399
                self.argList()


            self.state = 1402
            self.endOfStatement()
            self.state = 1404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1403
                self.block()


            self.state = 1406
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyLetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PROPERTY_LET(self):
            return self.getToken(vbaParser.PROPERTY_LET, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertyLetStmt

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

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




    def propertyLetStmt(self):

        localctx = vbaParser.PropertyLetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_propertyLetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 1408
                self.visibility()
                self.state = 1409
                self.match(vbaParser.WS)


            self.state = 1415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.STATIC:
                self.state = 1413
                self.match(vbaParser.STATIC)
                self.state = 1414
                self.match(vbaParser.WS)


            self.state = 1417
            self.match(vbaParser.PROPERTY_LET)
            self.state = 1418
            self.match(vbaParser.WS)
            self.state = 1419
            self.ambiguousIdentifier()
            self.state = 1424
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
            if la_ == 1:
                self.state = 1421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1420
                    self.match(vbaParser.WS)


                self.state = 1423
                self.argList()


            self.state = 1426
            self.endOfStatement()
            self.state = 1428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1427
                self.block()


            self.state = 1430
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PutStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PUT(self):
            return self.getToken(vbaParser.PUT, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_putStmt

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

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




    def putStmt(self):

        localctx = vbaParser.PutStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_putStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1432
            self.match(vbaParser.PUT)
            self.state = 1433
            self.match(vbaParser.WS)
            self.state = 1434
            self.fileNumber()
            self.state = 1436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1435
                self.match(vbaParser.WS)


            self.state = 1438
            self.match(vbaParser.T__0)
            self.state = 1440
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1439
                self.match(vbaParser.WS)


            self.state = 1443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (vbaParser.LPAREN - 193)) | (1 << (vbaParser.MINUS - 193)) | (1 << (vbaParser.PLUS - 193)) | (1 << (vbaParser.STRINGLITERAL - 193)) | (1 << (vbaParser.OCTLITERAL - 193)) | (1 << (vbaParser.HEXLITERAL - 193)) | (1 << (vbaParser.SHORTLITERAL - 193)) | (1 << (vbaParser.INTEGERLITERAL - 193)) | (1 << (vbaParser.DOUBLELITERAL - 193)) | (1 << (vbaParser.DATELITERAL - 193)) | (1 << (vbaParser.IDENTIFIER - 193)))) != 0):
                self.state = 1442
                self.valueStmt(0)


            self.state = 1446
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1445
                self.match(vbaParser.WS)


            self.state = 1448
            self.match(vbaParser.T__0)
            self.state = 1450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1449
                self.match(vbaParser.WS)


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


    class RaiseEventStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RAISEEVENT(self):
            return self.getToken(vbaParser.RAISEEVENT, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


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

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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_raiseEventStmt

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

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




    def raiseEventStmt(self):

        localctx = vbaParser.RaiseEventStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_raiseEventStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1454
            self.match(vbaParser.RAISEEVENT)
            self.state = 1455
            self.match(vbaParser.WS)
            self.state = 1456
            self.ambiguousIdentifier()
            self.state = 1471
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
            if la_ == 1:
                self.state = 1458
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1457
                    self.match(vbaParser.WS)


                self.state = 1460
                self.match(vbaParser.LPAREN)
                self.state = 1462
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
                if la_ == 1:
                    self.state = 1461
                    self.match(vbaParser.WS)


                self.state = 1468
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                if la_ == 1:
                    self.state = 1464
                    self.argsCall()
                    self.state = 1466
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1465
                        self.match(vbaParser.WS)




                self.state = 1470
                self.match(vbaParser.RPAREN)


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


    class RandomizeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RANDOMIZE(self):
            return self.getToken(vbaParser.RANDOMIZE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_randomizeStmt

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

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




    def randomizeStmt(self):

        localctx = vbaParser.RandomizeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_randomizeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1473
            self.match(vbaParser.RANDOMIZE)
            self.state = 1476
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.state = 1474
                self.match(vbaParser.WS)
                self.state = 1475
                self.valueStmt(0)


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


    class RedimStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REDIM(self):
            return self.getToken(vbaParser.REDIM, 0)

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

        def redimSubStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.RedimSubStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.RedimSubStmtContext,i)


        def PRESERVE(self):
            return self.getToken(vbaParser.PRESERVE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_redimStmt

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

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




    def redimStmt(self):

        localctx = vbaParser.RedimStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_redimStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1478
            self.match(vbaParser.REDIM)
            self.state = 1479
            self.match(vbaParser.WS)
            self.state = 1482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
            if la_ == 1:
                self.state = 1480
                self.match(vbaParser.PRESERVE)
                self.state = 1481
                self.match(vbaParser.WS)


            self.state = 1484
            self.redimSubStmt()
            self.state = 1495
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1486
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1485
                        self.match(vbaParser.WS)


                    self.state = 1488
                    self.match(vbaParser.T__0)
                    self.state = 1490
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1489
                        self.match(vbaParser.WS)


                    self.state = 1492
                    self.redimSubStmt() 
                self.state = 1497
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,207,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 RedimSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


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

        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


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

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

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_redimSubStmt

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

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




    def redimSubStmt(self):

        localctx = vbaParser.RedimSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_redimSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1498
            self.implicitCallStmt_InStmt()
            self.state = 1500
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1499
                self.match(vbaParser.WS)


            self.state = 1502
            self.match(vbaParser.LPAREN)
            self.state = 1504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1503
                self.match(vbaParser.WS)


            self.state = 1506
            self.subscripts()
            self.state = 1508
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1507
                self.match(vbaParser.WS)


            self.state = 1510
            self.match(vbaParser.RPAREN)
            self.state = 1513
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
            if la_ == 1:
                self.state = 1511
                self.match(vbaParser.WS)
                self.state = 1512
                self.asTypeClause()


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


    class ResetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RESET(self):
            return self.getToken(vbaParser.RESET, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_resetStmt

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

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




    def resetStmt(self):

        localctx = vbaParser.ResetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_resetStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1515
            self.match(vbaParser.RESET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResumeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RESUME(self):
            return self.getToken(vbaParser.RESUME, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_resumeStmt

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

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




    def resumeStmt(self):

        localctx = vbaParser.ResumeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_resumeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1517
            self.match(vbaParser.RESUME)
            self.state = 1523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.state = 1518
                self.match(vbaParser.WS)
                self.state = 1521
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1519
                    self.match(vbaParser.NEXT)
                    pass

                elif la_ == 2:
                    self.state = 1520
                    self.ambiguousIdentifier()
                    pass




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


    class ReturnStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURN(self):
            return self.getToken(vbaParser.RETURN, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_returnStmt

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

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




    def returnStmt(self):

        localctx = vbaParser.ReturnStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_returnStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1525
            self.match(vbaParser.RETURN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RmdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RMDIR(self):
            return self.getToken(vbaParser.RMDIR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_rmdirStmt

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

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




    def rmdirStmt(self):

        localctx = vbaParser.RmdirStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_rmdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1527
            self.match(vbaParser.RMDIR)
            self.state = 1528
            self.match(vbaParser.WS)
            self.state = 1529
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RsetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RSET(self):
            return self.getToken(vbaParser.RSET, 0)

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_rsetStmt

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

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




    def rsetStmt(self):

        localctx = vbaParser.RsetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_rsetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            self.match(vbaParser.RSET)
            self.state = 1532
            self.match(vbaParser.WS)
            self.state = 1533
            self.implicitCallStmt_InStmt()
            self.state = 1535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1534
                self.match(vbaParser.WS)


            self.state = 1537
            self.match(vbaParser.EQ)
            self.state = 1539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1538
                self.match(vbaParser.WS)


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


    class SavepictureStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SAVEPICTURE(self):
            return self.getToken(vbaParser.SAVEPICTURE, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_savepictureStmt

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

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




    def savepictureStmt(self):

        localctx = vbaParser.SavepictureStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_savepictureStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1543
            self.match(vbaParser.SAVEPICTURE)
            self.state = 1544
            self.match(vbaParser.WS)
            self.state = 1545
            self.valueStmt(0)
            self.state = 1547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1546
                self.match(vbaParser.WS)


            self.state = 1549
            self.match(vbaParser.T__0)
            self.state = 1551
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1550
                self.match(vbaParser.WS)


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


    class SaveSettingStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SAVESETTING(self):
            return self.getToken(vbaParser.SAVESETTING, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_saveSettingStmt

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

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




    def saveSettingStmt(self):

        localctx = vbaParser.SaveSettingStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_saveSettingStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1555
            self.match(vbaParser.SAVESETTING)
            self.state = 1556
            self.match(vbaParser.WS)
            self.state = 1557
            self.valueStmt(0)
            self.state = 1559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1558
                self.match(vbaParser.WS)


            self.state = 1561
            self.match(vbaParser.T__0)
            self.state = 1563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1562
                self.match(vbaParser.WS)


            self.state = 1565
            self.valueStmt(0)
            self.state = 1567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1566
                self.match(vbaParser.WS)


            self.state = 1569
            self.match(vbaParser.T__0)
            self.state = 1571
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1570
                self.match(vbaParser.WS)


            self.state = 1573
            self.valueStmt(0)
            self.state = 1575
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1574
                self.match(vbaParser.WS)


            self.state = 1577
            self.match(vbaParser.T__0)
            self.state = 1579
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1578
                self.match(vbaParser.WS)


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


    class SeekStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SEEK(self):
            return self.getToken(vbaParser.SEEK, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_seekStmt

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

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




    def seekStmt(self):

        localctx = vbaParser.SeekStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_seekStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1583
            self.match(vbaParser.SEEK)
            self.state = 1584
            self.match(vbaParser.WS)
            self.state = 1585
            self.fileNumber()
            self.state = 1587
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1586
                self.match(vbaParser.WS)


            self.state = 1589
            self.match(vbaParser.T__0)
            self.state = 1591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1590
                self.match(vbaParser.WS)


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


    class SelectCaseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SELECT(self):
            return self.getToken(vbaParser.SELECT, 0)

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

        def CASE(self):
            return self.getToken(vbaParser.CASE, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_SELECT(self):
            return self.getToken(vbaParser.END_SELECT, 0)

        def sC_Case(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SC_CaseContext)
            else:
                return self.getTypedRuleContext(vbaParser.SC_CaseContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_selectCaseStmt

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

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




    def selectCaseStmt(self):

        localctx = vbaParser.SelectCaseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_selectCaseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1595
            self.match(vbaParser.SELECT)
            self.state = 1596
            self.match(vbaParser.WS)
            self.state = 1597
            self.match(vbaParser.CASE)
            self.state = 1598
            self.match(vbaParser.WS)
            self.state = 1599
            self.valueStmt(0)
            self.state = 1600
            self.endOfStatement()
            self.state = 1604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==vbaParser.CASE:
                self.state = 1601
                self.sC_Case()
                self.state = 1606
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1607
            self.match(vbaParser.END_SELECT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SC_SelectionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Selection

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



    class CaseCondValueContext(SC_SelectionContext):

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

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


    class CaseCondToContext(SC_SelectionContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)
        def TO(self):
            return self.getToken(vbaParser.TO, 0)

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

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


    class CaseCondIsContext(SC_SelectionContext):

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

        def IS(self):
            return self.getToken(vbaParser.IS, 0)
        def comparisonOperator(self):
            return self.getTypedRuleContext(vbaParser.ComparisonOperatorContext,0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

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

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

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



    def sC_Selection(self):

        localctx = vbaParser.SC_SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_sC_Selection)
        self._la = 0 # Token type
        try:
            self.state = 1626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondIsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1609
                self.match(vbaParser.IS)
                self.state = 1611
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1610
                    self.match(vbaParser.WS)


                self.state = 1613
                self.comparisonOperator()
                self.state = 1615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1614
                    self.match(vbaParser.WS)


                self.state = 1617
                self.valueStmt(0)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondToContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1619
                self.valueStmt(0)
                self.state = 1620
                self.match(vbaParser.WS)
                self.state = 1621
                self.match(vbaParser.TO)
                self.state = 1622
                self.match(vbaParser.WS)
                self.state = 1623
                self.valueStmt(0)
                pass

            elif la_ == 3:
                localctx = vbaParser.CaseCondValueContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1625
                self.valueStmt(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 SC_CaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CASE(self):
            return self.getToken(vbaParser.CASE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def sC_Cond(self):
            return self.getTypedRuleContext(vbaParser.SC_CondContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Case

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

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




    def sC_Case(self):

        localctx = vbaParser.SC_CaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_sC_Case)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1628
            self.match(vbaParser.CASE)
            self.state = 1629
            self.match(vbaParser.WS)
            self.state = 1630
            self.sC_Cond()
            self.state = 1631
            self.endOfStatement()
            self.state = 1633
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.state = 1632
                self.block()


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


    class SC_CondContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Cond

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



    class CaseCondSelectionContext(SC_CondContext):

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

        def sC_Selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SC_SelectionContext)
            else:
                return self.getTypedRuleContext(vbaParser.SC_SelectionContext,i)

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

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

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


    class CaseCondElseContext(SC_CondContext):

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

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

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

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



    def sC_Cond(self):

        localctx = vbaParser.SC_CondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_sC_Cond)
        self._la = 0 # Token type
        try:
            self.state = 1650
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondElseContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1635
                self.match(vbaParser.ELSE)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondSelectionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1636
                self.sC_Selection()
                self.state = 1647
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,233,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1638
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1637
                            self.match(vbaParser.WS)


                        self.state = 1640
                        self.match(vbaParser.T__0)
                        self.state = 1642
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1641
                            self.match(vbaParser.WS)


                        self.state = 1644
                        self.sC_Selection() 
                    self.state = 1649
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,233,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 SendkeysStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SENDKEYS(self):
            return self.getToken(vbaParser.SENDKEYS, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_sendkeysStmt

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

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




    def sendkeysStmt(self):

        localctx = vbaParser.SendkeysStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_sendkeysStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1652
            self.match(vbaParser.SENDKEYS)
            self.state = 1653
            self.match(vbaParser.WS)
            self.state = 1654
            self.valueStmt(0)
            self.state = 1663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
            if la_ == 1:
                self.state = 1656
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1655
                    self.match(vbaParser.WS)


                self.state = 1658
                self.match(vbaParser.T__0)
                self.state = 1660
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1659
                    self.match(vbaParser.WS)


                self.state = 1662
                self.valueStmt(0)


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


    class SetattrStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SETATTR(self):
            return self.getToken(vbaParser.SETATTR, 0)

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_setattrStmt

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

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




    def setattrStmt(self):

        localctx = vbaParser.SetattrStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_setattrStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1665
            self.match(vbaParser.SETATTR)
            self.state = 1666
            self.match(vbaParser.WS)
            self.state = 1667
            self.valueStmt(0)
            self.state = 1669
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1668
                self.match(vbaParser.WS)


            self.state = 1671
            self.match(vbaParser.T__0)
            self.state = 1673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1672
                self.match(vbaParser.WS)


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


    class SetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SET(self):
            return self.getToken(vbaParser.SET, 0)

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_setStmt

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

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




    def setStmt(self):

        localctx = vbaParser.SetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_setStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1677
            self.match(vbaParser.SET)
            self.state = 1678
            self.match(vbaParser.WS)
            self.state = 1679
            self.implicitCallStmt_InStmt()
            self.state = 1681
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1680
                self.match(vbaParser.WS)


            self.state = 1683
            self.match(vbaParser.EQ)
            self.state = 1685
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1684
                self.match(vbaParser.WS)


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


    class StopStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def STOP(self):
            return self.getToken(vbaParser.STOP, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_stopStmt

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

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




    def stopStmt(self):

        localctx = vbaParser.StopStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_stopStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1689
            self.match(vbaParser.STOP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SUB(self):
            return self.getToken(vbaParser.SUB, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_SUB(self):
            return self.getToken(vbaParser.END_SUB, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


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

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_subStmt

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

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




    def subStmt(self):

        localctx = vbaParser.SubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_subStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1694
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 1691
                self.visibility()
                self.state = 1692
                self.match(vbaParser.WS)


            self.state = 1698
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.STATIC:
                self.state = 1696
                self.match(vbaParser.STATIC)
                self.state = 1697
                self.match(vbaParser.WS)


            self.state = 1700
            self.match(vbaParser.SUB)
            self.state = 1702
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1701
                self.match(vbaParser.WS)


            self.state = 1704
            self.ambiguousIdentifier()
            self.state = 1709
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,246,self._ctx)
            if la_ == 1:
                self.state = 1706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1705
                    self.match(vbaParser.WS)


                self.state = 1708
                self.argList()


            self.state = 1711
            self.endOfStatement()
            self.state = 1713
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1712
                self.block()


            self.state = 1715
            self.match(vbaParser.END_SUB)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TimeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TIME(self):
            return self.getToken(vbaParser.TIME, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_timeStmt

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

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




    def timeStmt(self):

        localctx = vbaParser.TimeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_timeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1717
            self.match(vbaParser.TIME)
            self.state = 1719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1718
                self.match(vbaParser.WS)


            self.state = 1721
            self.match(vbaParser.EQ)
            self.state = 1723
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 1722
                self.match(vbaParser.WS)


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


    class TypeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TYPE(self):
            return self.getToken(vbaParser.TYPE, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_TYPE(self):
            return self.getToken(vbaParser.END_TYPE, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def typeStmt_Element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.TypeStmt_ElementContext)
            else:
                return self.getTypedRuleContext(vbaParser.TypeStmt_ElementContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_typeStmt

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

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




    def typeStmt(self):

        localctx = vbaParser.TypeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_typeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 0):
                self.state = 1727
                self.visibility()
                self.state = 1728
                self.match(vbaParser.WS)


            self.state = 1732
            self.match(vbaParser.TYPE)
            self.state = 1733
            self.match(vbaParser.WS)
            self.state = 1734
            self.ambiguousIdentifier()
            self.state = 1735
            self.endOfStatement()
            self.state = 1739
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 1736
                self.typeStmt_Element()
                self.state = 1741
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1742
            self.match(vbaParser.END_TYPE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeStmt_ElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


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

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

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

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_typeStmt_Element

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

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




    def typeStmt_Element(self):

        localctx = vbaParser.TypeStmt_ElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_typeStmt_Element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1744
            self.ambiguousIdentifier()
            self.state = 1759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.state = 1746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1745
                    self.match(vbaParser.WS)


                self.state = 1748
                self.match(vbaParser.LPAREN)
                self.state = 1753
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,254,self._ctx)
                if la_ == 1:
                    self.state = 1750
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1749
                        self.match(vbaParser.WS)


                    self.state = 1752
                    self.subscripts()


                self.state = 1756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1755
                    self.match(vbaParser.WS)


                self.state = 1758
                self.match(vbaParser.RPAREN)


            self.state = 1763
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
            if la_ == 1:
                self.state = 1761
                self.match(vbaParser.WS)
                self.state = 1762
                self.asTypeClause()


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


    class TypeOfStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TYPEOF(self):
            return self.getToken(vbaParser.TYPEOF, 0)

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


        def getRuleIndex(self):
            return vbaParser.RULE_typeOfStmt

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

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




    def typeOfStmt(self):

        localctx = vbaParser.TypeOfStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_typeOfStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1767
            self.match(vbaParser.TYPEOF)
            self.state = 1768
            self.match(vbaParser.WS)
            self.state = 1769
            self.valueStmt(0)
            self.state = 1774
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1770
                self.match(vbaParser.WS)
                self.state = 1771
                self.match(vbaParser.IS)
                self.state = 1772
                self.match(vbaParser.WS)
                self.state = 1773
                self.type_()


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


    class UnloadStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNLOAD(self):
            return self.getToken(vbaParser.UNLOAD, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_unloadStmt

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

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




    def unloadStmt(self):

        localctx = vbaParser.UnloadStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_unloadStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1776
            self.match(vbaParser.UNLOAD)
            self.state = 1777
            self.match(vbaParser.WS)
            self.state = 1778
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNLOCK(self):
            return self.getToken(vbaParser.UNLOCK, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_unlockStmt

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

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




    def unlockStmt(self):

        localctx = vbaParser.UnlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_unlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1780
            self.match(vbaParser.UNLOCK)
            self.state = 1781
            self.match(vbaParser.WS)
            self.state = 1782
            self.fileNumber()
            self.state = 1797
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.state = 1784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1783
                    self.match(vbaParser.WS)


                self.state = 1786
                self.match(vbaParser.T__0)
                self.state = 1788
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1787
                    self.match(vbaParser.WS)


                self.state = 1790
                self.valueStmt(0)
                self.state = 1795
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1791
                    self.match(vbaParser.WS)
                    self.state = 1792
                    self.match(vbaParser.TO)
                    self.state = 1793
                    self.match(vbaParser.WS)
                    self.state = 1794
                    self.valueStmt(0)




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


    class ValueStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_valueStmt

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


    class VsStructContext(ValueStmtContext):

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

        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)
        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsAddContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def PLUS(self):
            return self.getToken(vbaParser.PLUS, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsLtContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def LT(self):
            return self.getToken(vbaParser.LT, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsAddressOfContext(ValueStmtContext):

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

        def ADDRESSOF(self):
            return self.getToken(vbaParser.ADDRESSOF, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

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


    class VsNewContext(ValueStmtContext):

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

        def NEW(self):
            return self.getToken(vbaParser.NEW, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

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


    class VsMultContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def MULT(self):
            return self.getToken(vbaParser.MULT, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsNegationContext(ValueStmtContext):

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

        def MINUS(self):
            return self.getToken(vbaParser.MINUS, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

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


    class VsAssignContext(ValueStmtContext):

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)

        def ASSIGN(self):
            return self.getToken(vbaParser.ASSIGN, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

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

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

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


    class VsLikeContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def LIKE(self):
            return self.getToken(vbaParser.LIKE, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsDivContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def DIV(self):
            return self.getToken(vbaParser.DIV, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsPlusContext(ValueStmtContext):

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

        def PLUS(self):
            return self.getToken(vbaParser.PLUS, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

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


    class VsNotContext(ValueStmtContext):

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

        def NOT(self):
            return self.getToken(vbaParser.NOT, 0)
        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

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


    class VsGeqContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def GEQ(self):
            return self.getToken(vbaParser.GEQ, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsTypeOfContext(ValueStmtContext):

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

        def typeOfStmt(self):
            return self.getTypedRuleContext(vbaParser.TypeOfStmtContext,0)


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

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


    class VsICSContext(ValueStmtContext):

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

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


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

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


    class VsNeqContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def NEQ(self):
            return self.getToken(vbaParser.NEQ, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsXorContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def XOR(self):
            return self.getToken(vbaParser.XOR, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsAndContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def AND(self):
            return self.getToken(vbaParser.AND, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsLeqContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def LEQ(self):
            return self.getToken(vbaParser.LEQ, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsPowContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def POW(self):
            return self.getToken(vbaParser.POW, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsIsContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def IS(self):
            return self.getToken(vbaParser.IS, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsModContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def MOD(self):
            return self.getToken(vbaParser.MOD, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsAmpContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def AMPERSAND(self):
            return self.getToken(vbaParser.AMPERSAND, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsOrContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def OR(self):
            return self.getToken(vbaParser.OR, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsMinusContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def MINUS(self):
            return self.getToken(vbaParser.MINUS, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsLiteralContext(ValueStmtContext):

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

        def literal(self):
            return self.getTypedRuleContext(vbaParser.LiteralContext,0)


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

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


    class VsEqvContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def EQV(self):
            return self.getToken(vbaParser.EQV, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsImpContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def IMP(self):
            return self.getToken(vbaParser.IMP, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsGtContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def GT(self):
            return self.getToken(vbaParser.GT, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsEqContext(ValueStmtContext):

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)
        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

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

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


    class VsMidContext(ValueStmtContext):

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

        def midStmt(self):
            return self.getTypedRuleContext(vbaParser.MidStmtContext,0)


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

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



    def valueStmt(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = vbaParser.ValueStmtContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 200
        self.enterRecursionRule(localctx, 200, self.RULE_valueStmt, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1859
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                localctx = vbaParser.VsLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1800
                self.literal()
                pass

            elif la_ == 2:
                localctx = vbaParser.VsICSContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1801
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 3:
                localctx = vbaParser.VsStructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1802
                self.match(vbaParser.LPAREN)
                self.state = 1804
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1803
                    self.match(vbaParser.WS)


                self.state = 1806
                self.valueStmt(0)
                self.state = 1817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==vbaParser.T__0 or _la==vbaParser.WS:
                    self.state = 1808
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1807
                        self.match(vbaParser.WS)


                    self.state = 1810
                    self.match(vbaParser.T__0)
                    self.state = 1812
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 1811
                        self.match(vbaParser.WS)


                    self.state = 1814
                    self.valueStmt(0)
                    self.state = 1819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1820
                self.match(vbaParser.RPAREN)
                pass

            elif la_ == 4:
                localctx = vbaParser.VsNewContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1822
                self.match(vbaParser.NEW)
                self.state = 1824
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1823
                    self.match(vbaParser.WS)


                self.state = 1826
                self.valueStmt(28)
                pass

            elif la_ == 5:
                localctx = vbaParser.VsTypeOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1827
                self.typeOfStmt()
                pass

            elif la_ == 6:
                localctx = vbaParser.VsMidContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1828
                self.midStmt()
                pass

            elif la_ == 7:
                localctx = vbaParser.VsAddressOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1829
                self.match(vbaParser.ADDRESSOF)
                self.state = 1831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1830
                    self.match(vbaParser.WS)


                self.state = 1833
                self.valueStmt(25)
                pass

            elif la_ == 8:
                localctx = vbaParser.VsAssignContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1834
                self.implicitCallStmt_InStmt()
                self.state = 1836
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1835
                    self.match(vbaParser.WS)


                self.state = 1838
                self.match(vbaParser.ASSIGN)
                self.state = 1840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1839
                    self.match(vbaParser.WS)


                self.state = 1842
                self.valueStmt(24)
                pass

            elif la_ == 9:
                localctx = vbaParser.VsNegationContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1844
                self.match(vbaParser.MINUS)
                self.state = 1846
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1845
                    self.match(vbaParser.WS)


                self.state = 1848
                self.valueStmt(14)
                pass

            elif la_ == 10:
                localctx = vbaParser.VsPlusContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1849
                self.match(vbaParser.PLUS)
                self.state = 1851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1850
                    self.match(vbaParser.WS)


                self.state = 1853
                self.valueStmt(13)
                pass

            elif la_ == 11:
                localctx = vbaParser.VsNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1854
                self.match(vbaParser.NOT)
                self.state = 1856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 1855
                    self.match(vbaParser.WS)


                self.state = 1858
                self.valueStmt(1)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2043
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,316,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 = 2041
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,315,self._ctx)
                    if la_ == 1:
                        localctx = vbaParser.VsIsContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1861
                        if not self.precpred(self._ctx, 23):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 23)")
                        self.state = 1863
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1862
                            self.match(vbaParser.WS)


                        self.state = 1865
                        self.match(vbaParser.IS)
                        self.state = 1867
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1866
                            self.match(vbaParser.WS)


                        self.state = 1869
                        self.valueStmt(24)
                        pass

                    elif la_ == 2:
                        localctx = vbaParser.VsLikeContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1870
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 1872
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1871
                            self.match(vbaParser.WS)


                        self.state = 1874
                        self.match(vbaParser.LIKE)
                        self.state = 1876
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1875
                            self.match(vbaParser.WS)


                        self.state = 1878
                        self.valueStmt(23)
                        pass

                    elif la_ == 3:
                        localctx = vbaParser.VsGeqContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1879
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 1881
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1880
                            self.match(vbaParser.WS)


                        self.state = 1883
                        self.match(vbaParser.GEQ)
                        self.state = 1885
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1884
                            self.match(vbaParser.WS)


                        self.state = 1887
                        self.valueStmt(22)
                        pass

                    elif la_ == 4:
                        localctx = vbaParser.VsLeqContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1888
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 1890
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1889
                            self.match(vbaParser.WS)


                        self.state = 1892
                        self.match(vbaParser.LEQ)
                        self.state = 1894
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1893
                            self.match(vbaParser.WS)


                        self.state = 1896
                        self.valueStmt(21)
                        pass

                    elif la_ == 5:
                        localctx = vbaParser.VsGtContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1897
                        if not self.precpred(self._ctx, 19):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
                        self.state = 1899
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1898
                            self.match(vbaParser.WS)


                        self.state = 1901
                        self.match(vbaParser.GT)
                        self.state = 1903
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1902
                            self.match(vbaParser.WS)


                        self.state = 1905
                        self.valueStmt(20)
                        pass

                    elif la_ == 6:
                        localctx = vbaParser.VsLtContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1906
                        if not self.precpred(self._ctx, 18):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
                        self.state = 1908
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1907
                            self.match(vbaParser.WS)


                        self.state = 1910
                        self.match(vbaParser.LT)
                        self.state = 1912
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1911
                            self.match(vbaParser.WS)


                        self.state = 1914
                        self.valueStmt(19)
                        pass

                    elif la_ == 7:
                        localctx = vbaParser.VsNeqContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1915
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 1917
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1916
                            self.match(vbaParser.WS)


                        self.state = 1919
                        self.match(vbaParser.NEQ)
                        self.state = 1921
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1920
                            self.match(vbaParser.WS)


                        self.state = 1923
                        self.valueStmt(18)
                        pass

                    elif la_ == 8:
                        localctx = vbaParser.VsEqContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1924
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 1926
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1925
                            self.match(vbaParser.WS)


                        self.state = 1928
                        self.match(vbaParser.EQ)
                        self.state = 1930
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1929
                            self.match(vbaParser.WS)


                        self.state = 1932
                        self.valueStmt(17)
                        pass

                    elif la_ == 9:
                        localctx = vbaParser.VsPowContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1933
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 1935
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1934
                            self.match(vbaParser.WS)


                        self.state = 1937
                        self.match(vbaParser.POW)
                        self.state = 1939
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1938
                            self.match(vbaParser.WS)


                        self.state = 1941
                        self.valueStmt(16)
                        pass

                    elif la_ == 10:
                        localctx = vbaParser.VsDivContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1942
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1944
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1943
                            self.match(vbaParser.WS)


                        self.state = 1946
                        self.match(vbaParser.DIV)
                        self.state = 1948
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1947
                            self.match(vbaParser.WS)


                        self.state = 1950
                        self.valueStmt(13)
                        pass

                    elif la_ == 11:
                        localctx = vbaParser.VsMultContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1951
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1953
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1952
                            self.match(vbaParser.WS)


                        self.state = 1955
                        self.match(vbaParser.MULT)
                        self.state = 1957
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1956
                            self.match(vbaParser.WS)


                        self.state = 1959
                        self.valueStmt(12)
                        pass

                    elif la_ == 12:
                        localctx = vbaParser.VsModContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1960
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1962
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1961
                            self.match(vbaParser.WS)


                        self.state = 1964
                        self.match(vbaParser.MOD)
                        self.state = 1966
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1965
                            self.match(vbaParser.WS)


                        self.state = 1968
                        self.valueStmt(11)
                        pass

                    elif la_ == 13:
                        localctx = vbaParser.VsAddContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1969
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1971
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1970
                            self.match(vbaParser.WS)


                        self.state = 1973
                        self.match(vbaParser.PLUS)
                        self.state = 1975
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1974
                            self.match(vbaParser.WS)


                        self.state = 1977
                        self.valueStmt(10)
                        pass

                    elif la_ == 14:
                        localctx = vbaParser.VsMinusContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1978
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1980
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1979
                            self.match(vbaParser.WS)


                        self.state = 1982
                        self.match(vbaParser.MINUS)
                        self.state = 1984
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1983
                            self.match(vbaParser.WS)


                        self.state = 1986
                        self.valueStmt(9)
                        pass

                    elif la_ == 15:
                        localctx = vbaParser.VsAmpContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1987
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1989
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1988
                            self.match(vbaParser.WS)


                        self.state = 1991
                        self.match(vbaParser.AMPERSAND)
                        self.state = 1993
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1992
                            self.match(vbaParser.WS)


                        self.state = 1995
                        self.valueStmt(8)
                        pass

                    elif la_ == 16:
                        localctx = vbaParser.VsImpContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1996
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1998
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 1997
                            self.match(vbaParser.WS)


                        self.state = 2000
                        self.match(vbaParser.IMP)
                        self.state = 2002
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2001
                            self.match(vbaParser.WS)


                        self.state = 2004
                        self.valueStmt(7)
                        pass

                    elif la_ == 17:
                        localctx = vbaParser.VsEqvContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 2005
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 2007
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2006
                            self.match(vbaParser.WS)


                        self.state = 2009
                        self.match(vbaParser.EQV)
                        self.state = 2011
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2010
                            self.match(vbaParser.WS)


                        self.state = 2013
                        self.valueStmt(6)
                        pass

                    elif la_ == 18:
                        localctx = vbaParser.VsXorContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 2014
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 2016
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2015
                            self.match(vbaParser.WS)


                        self.state = 2018
                        self.match(vbaParser.XOR)
                        self.state = 2020
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2019
                            self.match(vbaParser.WS)


                        self.state = 2022
                        self.valueStmt(5)
                        pass

                    elif la_ == 19:
                        localctx = vbaParser.VsOrContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 2023
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 2025
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2024
                            self.match(vbaParser.WS)


                        self.state = 2027
                        self.match(vbaParser.OR)
                        self.state = 2029
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2028
                            self.match(vbaParser.WS)


                        self.state = 2031
                        self.valueStmt(4)
                        pass

                    elif la_ == 20:
                        localctx = vbaParser.VsAndContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 2032
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 2034
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2033
                            self.match(vbaParser.WS)


                        self.state = 2036
                        self.match(vbaParser.AND)
                        self.state = 2038
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2037
                            self.match(vbaParser.WS)


                        self.state = 2040
                        self.valueStmt(3)
                        pass

             
                self.state = 2045
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,316,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 VariableStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def variableListStmt(self):
            return self.getTypedRuleContext(vbaParser.VariableListStmtContext,0)


        def DIM(self):
            return self.getToken(vbaParser.DIM, 0)

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def WITHEVENTS(self):
            return self.getToken(vbaParser.WITHEVENTS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_variableStmt

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

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




    def variableStmt(self):

        localctx = vbaParser.VariableStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_variableStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2049
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.DIM]:
                self.state = 2046
                self.match(vbaParser.DIM)
                pass
            elif token in [vbaParser.STATIC]:
                self.state = 2047
                self.match(vbaParser.STATIC)
                pass
            elif token in [vbaParser.FRIEND, vbaParser.GLOBAL, vbaParser.PRIVATE, vbaParser.PUBLIC]:
                self.state = 2048
                self.visibility()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2051
            self.match(vbaParser.WS)
            self.state = 2054
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,318,self._ctx)
            if la_ == 1:
                self.state = 2052
                self.match(vbaParser.WITHEVENTS)
                self.state = 2053
                self.match(vbaParser.WS)


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


    class VariableListStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableSubStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.VariableSubStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.VariableSubStmtContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_variableListStmt

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

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




    def variableListStmt(self):

        localctx = vbaParser.VariableListStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_variableListStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2058
            self.variableSubStmt()
            self.state = 2069
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,321,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2060
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2059
                        self.match(vbaParser.WS)


                    self.state = 2062
                    self.match(vbaParser.T__0)
                    self.state = 2064
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2063
                        self.match(vbaParser.WS)


                    self.state = 2066
                    self.variableSubStmt() 
                self.state = 2071
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,321,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 VariableSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


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

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

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_variableSubStmt

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

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




    def variableSubStmt(self):

        localctx = vbaParser.VariableSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_variableSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2072
            self.ambiguousIdentifier()
            self.state = 2090
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
            if la_ == 1:
                self.state = 2074
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2073
                    self.match(vbaParser.WS)


                self.state = 2076
                self.match(vbaParser.LPAREN)
                self.state = 2078
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2077
                    self.match(vbaParser.WS)


                self.state = 2084
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (vbaParser.LPAREN - 193)) | (1 << (vbaParser.MINUS - 193)) | (1 << (vbaParser.PLUS - 193)) | (1 << (vbaParser.STRINGLITERAL - 193)) | (1 << (vbaParser.OCTLITERAL - 193)) | (1 << (vbaParser.HEXLITERAL - 193)) | (1 << (vbaParser.SHORTLITERAL - 193)) | (1 << (vbaParser.INTEGERLITERAL - 193)) | (1 << (vbaParser.DOUBLELITERAL - 193)) | (1 << (vbaParser.DATELITERAL - 193)) | (1 << (vbaParser.IDENTIFIER - 193)))) != 0):
                    self.state = 2080
                    self.subscripts()
                    self.state = 2082
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2081
                        self.match(vbaParser.WS)




                self.state = 2086
                self.match(vbaParser.RPAREN)
                self.state = 2088
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
                if la_ == 1:
                    self.state = 2087
                    self.match(vbaParser.WS)




            self.state = 2093
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,328,self._ctx)
            if la_ == 1:
                self.state = 2092
                self.typeHint()


            self.state = 2097
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
            if la_ == 1:
                self.state = 2095
                self.match(vbaParser.WS)
                self.state = 2096
                self.asTypeClause()


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


    class WhileWendStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHILE(self):
            return self.getToken(vbaParser.WHILE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def WEND(self):
            return self.getToken(vbaParser.WEND, 0)

        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_whileWendStmt

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

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




    def whileWendStmt(self):

        localctx = vbaParser.WhileWendStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_whileWendStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2099
            self.match(vbaParser.WHILE)
            self.state = 2100
            self.match(vbaParser.WS)
            self.state = 2101
            self.valueStmt(0)
            self.state = 2102
            self.endOfStatement()
            self.state = 2104
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
            if la_ == 1:
                self.state = 2103
                self.block()


            self.state = 2106
            self.match(vbaParser.WEND)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WidthStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WIDTH(self):
            return self.getToken(vbaParser.WIDTH, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_widthStmt

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

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




    def widthStmt(self):

        localctx = vbaParser.WidthStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_widthStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2108
            self.match(vbaParser.WIDTH)
            self.state = 2109
            self.match(vbaParser.WS)
            self.state = 2110
            self.fileNumber()
            self.state = 2112
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2111
                self.match(vbaParser.WS)


            self.state = 2114
            self.match(vbaParser.T__0)
            self.state = 2116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2115
                self.match(vbaParser.WS)


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


    class WithStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WITH(self):
            return self.getToken(vbaParser.WITH, 0)

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

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_WITH(self):
            return self.getToken(vbaParser.END_WITH, 0)

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


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

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


        def getRuleIndex(self):
            return vbaParser.RULE_withStmt

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

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




    def withStmt(self):

        localctx = vbaParser.WithStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_withStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2120
            self.match(vbaParser.WITH)
            self.state = 2121
            self.match(vbaParser.WS)
            self.state = 2126
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,333,self._ctx)
            if la_ == 1:
                self.state = 2122
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 2:
                self.state = 2123
                self.match(vbaParser.NEW)
                self.state = 2124
                self.match(vbaParser.WS)
                self.state = 2125
                self.type_()
                pass


            self.state = 2128
            self.endOfStatement()
            self.state = 2130
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.EXIT_DO - 64)) | (1 << (vbaParser.EXIT_FOR - 64)) | (1 << (vbaParser.EXIT_FUNCTION - 64)) | (1 << (vbaParser.EXIT_PROPERTY - 64)) | (1 << (vbaParser.EXIT_SUB - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LINE_INPUT - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.MACRO_CONST - 64)) | (1 << (vbaParser.MACRO_IF - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.ON_ERROR - 64)) | (1 << (vbaParser.ON_LOCAL_ERROR - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or _la==vbaParser.IDENTIFIER:
                self.state = 2129
                self.block()


            self.state = 2132
            self.match(vbaParser.END_WITH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WriteStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WRITE(self):
            return self.getToken(vbaParser.WRITE, 0)

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

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def outputList(self):
            return self.getTypedRuleContext(vbaParser.OutputListContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_writeStmt

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

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




    def writeStmt(self):

        localctx = vbaParser.WriteStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_writeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2134
            self.match(vbaParser.WRITE)
            self.state = 2135
            self.match(vbaParser.WS)
            self.state = 2136
            self.fileNumber()
            self.state = 2138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2137
                self.match(vbaParser.WS)


            self.state = 2140
            self.match(vbaParser.T__0)
            self.state = 2145
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.state = 2142
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,336,self._ctx)
                if la_ == 1:
                    self.state = 2141
                    self.match(vbaParser.WS)


                self.state = 2144
                self.outputList()


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


    class FileNumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_fileNumber

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

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




    def fileNumber(self):

        localctx = vbaParser.FileNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_fileNumber)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2148
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.T__2:
                self.state = 2147
                self.match(vbaParser.T__2)


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


    class ExplicitCallStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def eCS_ProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ECS_ProcedureCallContext,0)


        def eCS_MemberProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ECS_MemberProcedureCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_explicitCallStmt

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

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




    def explicitCallStmt(self):

        localctx = vbaParser.ExplicitCallStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_explicitCallStmt)
        try:
            self.state = 2154
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,339,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2152
                self.eCS_ProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2153
                self.eCS_MemberProcedureCall()
                pass


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


    class ECS_ProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CALL(self):
            return self.getToken(vbaParser.CALL, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_eCS_ProcedureCall

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

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




    def eCS_ProcedureCall(self):

        localctx = vbaParser.ECS_ProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_eCS_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2156
            self.match(vbaParser.CALL)
            self.state = 2157
            self.match(vbaParser.WS)
            self.state = 2158
            self.ambiguousIdentifier()
            self.state = 2160
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,340,self._ctx)
            if la_ == 1:
                self.state = 2159
                self.typeHint()


            self.state = 2175
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.state = 2163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2162
                    self.match(vbaParser.WS)


                self.state = 2165
                self.match(vbaParser.LPAREN)
                self.state = 2167
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,342,self._ctx)
                if la_ == 1:
                    self.state = 2166
                    self.match(vbaParser.WS)


                self.state = 2169
                self.argsCall()
                self.state = 2171
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2170
                    self.match(vbaParser.WS)


                self.state = 2173
                self.match(vbaParser.RPAREN)


            self.state = 2186
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,346,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2178
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2177
                        self.match(vbaParser.WS)


                    self.state = 2180
                    self.match(vbaParser.LPAREN)
                    self.state = 2181
                    self.subscripts()
                    self.state = 2182
                    self.match(vbaParser.RPAREN) 
                self.state = 2188
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,346,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 ECS_MemberProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CALL(self):
            return self.getToken(vbaParser.CALL, 0)

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_eCS_MemberProcedureCall

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

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




    def eCS_MemberProcedureCall(self):

        localctx = vbaParser.ECS_MemberProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_eCS_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2189
            self.match(vbaParser.CALL)
            self.state = 2190
            self.match(vbaParser.WS)
            self.state = 2192
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,347,self._ctx)
            if la_ == 1:
                self.state = 2191
                self.implicitCallStmt_InStmt()


            self.state = 2194
            self.match(vbaParser.T__3)
            self.state = 2195
            self.ambiguousIdentifier()
            self.state = 2197
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,348,self._ctx)
            if la_ == 1:
                self.state = 2196
                self.typeHint()


            self.state = 2212
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,352,self._ctx)
            if la_ == 1:
                self.state = 2200
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2199
                    self.match(vbaParser.WS)


                self.state = 2202
                self.match(vbaParser.LPAREN)
                self.state = 2204
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,350,self._ctx)
                if la_ == 1:
                    self.state = 2203
                    self.match(vbaParser.WS)


                self.state = 2206
                self.argsCall()
                self.state = 2208
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2207
                    self.match(vbaParser.WS)


                self.state = 2210
                self.match(vbaParser.RPAREN)


            self.state = 2223
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,354,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2215
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2214
                        self.match(vbaParser.WS)


                    self.state = 2217
                    self.match(vbaParser.LPAREN)
                    self.state = 2218
                    self.subscripts()
                    self.state = 2219
                    self.match(vbaParser.RPAREN) 
                self.state = 2225
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,354,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 ImplicitCallStmt_InBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def iCS_B_MemberProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_B_MemberProcedureCallContext,0)


        def iCS_B_ProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_B_ProcedureCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_implicitCallStmt_InBlock

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

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




    def implicitCallStmt_InBlock(self):

        localctx = vbaParser.ImplicitCallStmt_InBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_implicitCallStmt_InBlock)
        try:
            self.state = 2228
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,355,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2226
                self.iCS_B_MemberProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2227
                self.iCS_B_ProcedureCall()
                pass


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


    class ICS_B_MemberProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_B_MemberProcedureCall

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

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




    def iCS_B_MemberProcedureCall(self):

        localctx = vbaParser.ICS_B_MemberProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_iCS_B_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2231
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,356,self._ctx)
            if la_ == 1:
                self.state = 2230
                self.implicitCallStmt_InStmt()


            self.state = 2233
            self.match(vbaParser.T__3)
            self.state = 2234
            self.ambiguousIdentifier()
            self.state = 2236
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
            if la_ == 1:
                self.state = 2235
                self.typeHint()


            self.state = 2240
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,358,self._ctx)
            if la_ == 1:
                self.state = 2238
                self.match(vbaParser.WS)
                self.state = 2239
                self.argsCall()


            self.state = 2243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,359,self._ctx)
            if la_ == 1:
                self.state = 2242
                self.dictionaryCallStmt()


            self.state = 2254
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,361,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2246
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2245
                        self.match(vbaParser.WS)


                    self.state = 2248
                    self.match(vbaParser.LPAREN)
                    self.state = 2249
                    self.subscripts()
                    self.state = 2250
                    self.match(vbaParser.RPAREN) 
                self.state = 2256
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,361,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 ICS_B_ProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def certainIdentifier(self):
            return self.getTypedRuleContext(vbaParser.CertainIdentifierContext,0)


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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_B_ProcedureCall

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

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




    def iCS_B_ProcedureCall(self):

        localctx = vbaParser.ICS_B_ProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_iCS_B_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2257
            self.certainIdentifier()
            self.state = 2260
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,362,self._ctx)
            if la_ == 1:
                self.state = 2258
                self.match(vbaParser.WS)
                self.state = 2259
                self.argsCall()


            self.state = 2271
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,364,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2263
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2262
                        self.match(vbaParser.WS)


                    self.state = 2265
                    self.match(vbaParser.LPAREN)
                    self.state = 2266
                    self.subscripts()
                    self.state = 2267
                    self.match(vbaParser.RPAREN) 
                self.state = 2273
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,364,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 ImplicitCallStmt_InStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def iCS_S_MembersCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_MembersCallContext,0)


        def iCS_S_VariableOrProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_VariableOrProcedureCallContext,0)


        def iCS_S_ProcedureOrArrayCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_ProcedureOrArrayCallContext,0)


        def iCS_S_DictionaryCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_DictionaryCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_implicitCallStmt_InStmt

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

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




    def implicitCallStmt_InStmt(self):

        localctx = vbaParser.ImplicitCallStmt_InStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_implicitCallStmt_InStmt)
        try:
            self.state = 2278
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,365,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2274
                self.iCS_S_MembersCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2275
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2276
                self.iCS_S_ProcedureOrArrayCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2277
                self.iCS_S_DictionaryCall()
                pass


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


    class ICS_S_VariableOrProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_VariableOrProcedureCall

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

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




    def iCS_S_VariableOrProcedureCall(self):

        localctx = vbaParser.ICS_S_VariableOrProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_iCS_S_VariableOrProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2280
            self.ambiguousIdentifier()
            self.state = 2282
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,366,self._ctx)
            if la_ == 1:
                self.state = 2281
                self.typeHint()


            self.state = 2285
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,367,self._ctx)
            if la_ == 1:
                self.state = 2284
                self.dictionaryCallStmt()


            self.state = 2296
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,369,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2288
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2287
                        self.match(vbaParser.WS)


                    self.state = 2290
                    self.match(vbaParser.LPAREN)
                    self.state = 2291
                    self.subscripts()
                    self.state = 2292
                    self.match(vbaParser.RPAREN) 
                self.state = 2298
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,369,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 ICS_S_ProcedureOrArrayCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def baseType(self):
            return self.getTypedRuleContext(vbaParser.BaseTypeContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_ProcedureOrArrayCall

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

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




    def iCS_S_ProcedureOrArrayCall(self):

        localctx = vbaParser.ICS_S_ProcedureOrArrayCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_iCS_S_ProcedureOrArrayCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2301
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,370,self._ctx)
            if la_ == 1:
                self.state = 2299
                self.ambiguousIdentifier()
                pass

            elif la_ == 2:
                self.state = 2300
                self.baseType()
                pass


            self.state = 2304
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 2303
                self.typeHint()


            self.state = 2307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2306
                self.match(vbaParser.WS)


            self.state = 2309
            self.match(vbaParser.LPAREN)
            self.state = 2311
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,373,self._ctx)
            if la_ == 1:
                self.state = 2310
                self.match(vbaParser.WS)


            self.state = 2317
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
            if la_ == 1:
                self.state = 2313
                self.argsCall()
                self.state = 2315
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2314
                    self.match(vbaParser.WS)




            self.state = 2319
            self.match(vbaParser.RPAREN)
            self.state = 2321
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,376,self._ctx)
            if la_ == 1:
                self.state = 2320
                self.dictionaryCallStmt()


            self.state = 2332
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,378,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2324
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2323
                        self.match(vbaParser.WS)


                    self.state = 2326
                    self.match(vbaParser.LPAREN)
                    self.state = 2327
                    self.subscripts()
                    self.state = 2328
                    self.match(vbaParser.RPAREN) 
                self.state = 2334
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,378,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 ICS_S_MembersCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def iCS_S_VariableOrProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_VariableOrProcedureCallContext,0)


        def iCS_S_ProcedureOrArrayCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_ProcedureOrArrayCallContext,0)


        def iCS_S_MemberCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ICS_S_MemberCallContext)
            else:
                return self.getTypedRuleContext(vbaParser.ICS_S_MemberCallContext,i)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


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

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_MembersCall

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

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




    def iCS_S_MembersCall(self):

        localctx = vbaParser.ICS_S_MembersCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_iCS_S_MembersCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,379,self._ctx)
            if la_ == 1:
                self.state = 2335
                self.iCS_S_VariableOrProcedureCall()

            elif la_ == 2:
                self.state = 2336
                self.iCS_S_ProcedureOrArrayCall()


            self.state = 2340 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2339
                    self.iCS_S_MemberCall()

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

            self.state = 2345
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,381,self._ctx)
            if la_ == 1:
                self.state = 2344
                self.dictionaryCallStmt()


            self.state = 2356
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,383,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2348
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2347
                        self.match(vbaParser.WS)


                    self.state = 2350
                    self.match(vbaParser.LPAREN)
                    self.state = 2351
                    self.subscripts()
                    self.state = 2352
                    self.match(vbaParser.RPAREN) 
                self.state = 2358
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,383,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 ICS_S_MemberCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def iCS_S_VariableOrProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_VariableOrProcedureCallContext,0)


        def iCS_S_ProcedureOrArrayCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_ProcedureOrArrayCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_MemberCall

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

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




    def iCS_S_MemberCall(self):

        localctx = vbaParser.ICS_S_MemberCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_iCS_S_MemberCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2359
            _la = self._input.LA(1)
            if not(_la==vbaParser.T__3 or _la==vbaParser.T__4):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2362
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,384,self._ctx)
            if la_ == 1:
                self.state = 2360
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 2:
                self.state = 2361
                self.iCS_S_ProcedureOrArrayCall()
                pass


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


    class ICS_S_DictionaryCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_DictionaryCall

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

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




    def iCS_S_DictionaryCall(self):

        localctx = vbaParser.ICS_S_DictionaryCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_iCS_S_DictionaryCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2364
            self.dictionaryCallStmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgsCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def argCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ArgCallContext)
            else:
                return self.getTypedRuleContext(vbaParser.ArgCallContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_argsCall

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

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




    def argsCall(self):

        localctx = vbaParser.ArgsCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_argsCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2378
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,388,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2367
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__3) | (1 << vbaParser.T__4) | (1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & ((1 << (vbaParser.LPAREN - 193)) | (1 << (vbaParser.MINUS - 193)) | (1 << (vbaParser.PLUS - 193)) | (1 << (vbaParser.RPAREN - 193)) | (1 << (vbaParser.STRINGLITERAL - 193)) | (1 << (vbaParser.OCTLITERAL - 193)) | (1 << (vbaParser.HEXLITERAL - 193)) | (1 << (vbaParser.SHORTLITERAL - 193)) | (1 << (vbaParser.INTEGERLITERAL - 193)) | (1 << (vbaParser.DOUBLELITERAL - 193)) | (1 << (vbaParser.DATELITERAL - 193)) | (1 << (vbaParser.IDENTIFIER - 193)))) != 0):
                        self.state = 2366
                        self.argCall()


                    self.state = 2370
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2369
                        self.match(vbaParser.WS)


                    self.state = 2372
                    _la = self._input.LA(1)
                    if not(_la==vbaParser.T__0 or _la==vbaParser.T__1):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2374
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,387,self._ctx)
                    if la_ == 1:
                        self.state = 2373
                        self.match(vbaParser.WS)

             
                self.state = 2380
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,388,self._ctx)

            self.state = 2381
            self.argCall()
            self.state = 2394
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,392,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2383
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2382
                        self.match(vbaParser.WS)


                    self.state = 2385
                    _la = self._input.LA(1)
                    if not(_la==vbaParser.T__0 or _la==vbaParser.T__1):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2387
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,390,self._ctx)
                    if la_ == 1:
                        self.state = 2386
                        self.match(vbaParser.WS)


                    self.state = 2390
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,391,self._ctx)
                    if la_ == 1:
                        self.state = 2389
                        self.argCall()

             
                self.state = 2396
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,392,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 ArgCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

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

        def BYVAL(self):
            return self.getToken(vbaParser.BYVAL, 0)

        def BYREF(self):
            return self.getToken(vbaParser.BYREF, 0)

        def PARAMARRAY(self):
            return self.getToken(vbaParser.PARAMARRAY, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_argCall

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

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




    def argCall(self):

        localctx = vbaParser.ArgCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_argCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2398
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
            if la_ == 1:
                self.state = 2397
                self.match(vbaParser.LPAREN)


            self.state = 2402
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,394,self._ctx)
            if la_ == 1:
                self.state = 2400
                _la = self._input.LA(1)
                if not(_la==vbaParser.BYVAL or _la==vbaParser.BYREF or _la==vbaParser.PARAMARRAY):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2401
                self.match(vbaParser.WS)


            self.state = 2405
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.RPAREN:
                self.state = 2404
                self.match(vbaParser.RPAREN)


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


    class DictionaryCallStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_dictionaryCallStmt

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

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




    def dictionaryCallStmt(self):

        localctx = vbaParser.DictionaryCallStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_dictionaryCallStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2409
            self.match(vbaParser.T__4)
            self.state = 2410
            self.ambiguousIdentifier()
            self.state = 2412
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,396,self._ctx)
            if la_ == 1:
                self.state = 2411
                self.typeHint()


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


    class ArgListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ArgContext)
            else:
                return self.getTypedRuleContext(vbaParser.ArgContext,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_argList

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

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




    def argList(self):

        localctx = vbaParser.ArgListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_argList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2414
            self.match(vbaParser.LPAREN)
            self.state = 2432
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,401,self._ctx)
            if la_ == 1:
                self.state = 2416
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2415
                    self.match(vbaParser.WS)


                self.state = 2418
                self.arg()
                self.state = 2429
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,400,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2420
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2419
                            self.match(vbaParser.WS)


                        self.state = 2422
                        self.match(vbaParser.T__0)
                        self.state = 2424
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2423
                            self.match(vbaParser.WS)


                        self.state = 2426
                        self.arg() 
                    self.state = 2431
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,400,self._ctx)



            self.state = 2435
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2434
                self.match(vbaParser.WS)


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


    class ArgContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def OPTIONAL(self):
            return self.getToken(vbaParser.OPTIONAL, 0)

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

        def PARAMARRAY(self):
            return self.getToken(vbaParser.PARAMARRAY, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


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

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

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def argDefaultValue(self):
            return self.getTypedRuleContext(vbaParser.ArgDefaultValueContext,0)


        def BYVAL(self):
            return self.getToken(vbaParser.BYVAL, 0)

        def BYREF(self):
            return self.getToken(vbaParser.BYREF, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_arg

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

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




    def arg(self):

        localctx = vbaParser.ArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2441
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,403,self._ctx)
            if la_ == 1:
                self.state = 2439
                self.match(vbaParser.OPTIONAL)
                self.state = 2440
                self.match(vbaParser.WS)


            self.state = 2445
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,404,self._ctx)
            if la_ == 1:
                self.state = 2443
                _la = self._input.LA(1)
                if not(_la==vbaParser.BYVAL or _la==vbaParser.BYREF):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2444
                self.match(vbaParser.WS)


            self.state = 2449
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,405,self._ctx)
            if la_ == 1:
                self.state = 2447
                self.match(vbaParser.PARAMARRAY)
                self.state = 2448
                self.match(vbaParser.WS)


            self.state = 2451
            self.ambiguousIdentifier()
            self.state = 2453
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND:
                self.state = 2452
                self.typeHint()


            self.state = 2463
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,409,self._ctx)
            if la_ == 1:
                self.state = 2456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2455
                    self.match(vbaParser.WS)


                self.state = 2458
                self.match(vbaParser.LPAREN)
                self.state = 2460
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2459
                    self.match(vbaParser.WS)


                self.state = 2462
                self.match(vbaParser.RPAREN)


            self.state = 2469
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,411,self._ctx)
            if la_ == 1:
                self.state = 2466
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2465
                    self.match(vbaParser.WS)


                self.state = 2468
                self.asTypeClause()


            self.state = 2475
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,413,self._ctx)
            if la_ == 1:
                self.state = 2472
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2471
                    self.match(vbaParser.WS)


                self.state = 2474
                self.argDefaultValue()


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


    class ArgDefaultValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_argDefaultValue

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

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




    def argDefaultValue(self):

        localctx = vbaParser.ArgDefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_argDefaultValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2477
            self.match(vbaParser.EQ)
            self.state = 2479
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2478
                self.match(vbaParser.WS)


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


    class SubscriptsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def subscript_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.Subscript_Context)
            else:
                return self.getTypedRuleContext(vbaParser.Subscript_Context,i)


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

        def getRuleIndex(self):
            return vbaParser.RULE_subscripts

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

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




    def subscripts(self):

        localctx = vbaParser.SubscriptsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_subscripts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2483
            self.subscript_()
            self.state = 2494
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,417,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2485
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2484
                        self.match(vbaParser.WS)


                    self.state = 2487
                    self.match(vbaParser.T__0)
                    self.state = 2489
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2488
                        self.match(vbaParser.WS)


                    self.state = 2491
                    self.subscript_() 
                self.state = 2496
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,417,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 Subscript_Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_subscript_

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

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




    def subscript_(self):

        localctx = vbaParser.Subscript_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_subscript_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2502
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,418,self._ctx)
            if la_ == 1:
                self.state = 2497
                self.valueStmt(0)
                self.state = 2498
                self.match(vbaParser.WS)
                self.state = 2499
                self.match(vbaParser.TO)
                self.state = 2500
                self.match(vbaParser.WS)


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


    class AmbiguousIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ambiguousKeyword(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousKeywordContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousKeywordContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_ambiguousIdentifier

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

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




    def ambiguousIdentifier(self):

        localctx = vbaParser.AmbiguousIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_ambiguousIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2508 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2508
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [vbaParser.IDENTIFIER]:
                        self.state = 2506
                        self.match(vbaParser.IDENTIFIER)
                        pass
                    elif token in [vbaParser.ACCESS, vbaParser.ADDRESSOF, vbaParser.ALIAS, vbaParser.AND, vbaParser.ATTRIBUTE, vbaParser.APPACTIVATE, vbaParser.APPEND, vbaParser.AS, vbaParser.BEGIN, vbaParser.BEEP, vbaParser.BINARY, vbaParser.BOOLEAN, vbaParser.BYVAL, vbaParser.BYREF, vbaParser.BYTE, vbaParser.CALL, vbaParser.CASE, vbaParser.CHDIR, vbaParser.CHDRIVE, vbaParser.CLASS, vbaParser.CLOSE, vbaParser.COLLECTION, vbaParser.CONST, vbaParser.DATABASE, vbaParser.DATE, vbaParser.DECLARE, vbaParser.DEFBOOL, vbaParser.DEFBYTE, vbaParser.DEFDATE, vbaParser.DEFDBL, vbaParser.DEFDEC, vbaParser.DEFCUR, vbaParser.DEFINT, vbaParser.DEFLNG, vbaParser.DEFOBJ, vbaParser.DEFSNG, vbaParser.DEFSTR, vbaParser.DEFVAR, vbaParser.DELETESETTING, vbaParser.DIM, vbaParser.DO, vbaParser.DOUBLE, vbaParser.EACH, vbaParser.ELSE, vbaParser.ELSEIF, vbaParser.END, vbaParser.ENUM, vbaParser.EQV, vbaParser.ERASE, vbaParser.ERROR, vbaParser.EVENT, vbaParser.FALSE, vbaParser.FILECOPY, vbaParser.FRIEND, vbaParser.FOR, vbaParser.FUNCTION, vbaParser.GET, vbaParser.GLOBAL, vbaParser.GOSUB, vbaParser.GOTO, vbaParser.IF, vbaParser.IMP, vbaParser.IMPLEMENTS, vbaParser.IN, vbaParser.INPUT, vbaParser.IS, vbaParser.INTEGER, vbaParser.KILL, vbaParser.LOAD, vbaParser.LOCK, vbaParser.LONG, vbaParser.LOOP, vbaParser.LEN, vbaParser.LET, vbaParser.LIB, vbaParser.LIKE, vbaParser.LSET, vbaParser.ME, vbaParser.MID, vbaParser.MKDIR, vbaParser.MOD, vbaParser.NAME, vbaParser.NEXT, vbaParser.NEW, vbaParser.NOT, vbaParser.NOTHING, vbaParser.NULL_, vbaParser.ON, vbaParser.OPEN, vbaParser.OPTIONAL, vbaParser.OR, vbaParser.OUTPUT, vbaParser.PARAMARRAY, vbaParser.PRESERVE, vbaParser.PRINT, vbaParser.PRIVATE, vbaParser.PUBLIC, vbaParser.PUT, vbaParser.RANDOM, vbaParser.RANDOMIZE, vbaParser.RAISEEVENT, vbaParser.READ, vbaParser.REDIM, vbaParser.REM, vbaParser.RESET, vbaParser.RESUME, vbaParser.RETURN, vbaParser.RMDIR, vbaParser.RSET, vbaParser.SAVEPICTURE, vbaParser.SAVESETTING, vbaParser.SEEK, vbaParser.SELECT, vbaParser.SENDKEYS, vbaParser.SET, vbaParser.SETATTR, vbaParser.SHARED, vbaParser.SINGLE, vbaParser.SPC, vbaParser.STATIC, vbaParser.STEP, vbaParser.STOP, vbaParser.STRING, vbaParser.SUB, vbaParser.TAB, vbaParser.TEXT, vbaParser.THEN, vbaParser.TIME, vbaParser.TO, vbaParser.TRUE, vbaParser.TYPE, vbaParser.TYPEOF, vbaParser.UNLOAD, vbaParser.UNLOCK, vbaParser.UNTIL, vbaParser.VARIANT, vbaParser.VERSION, vbaParser.WEND, vbaParser.WHILE, vbaParser.WIDTH, vbaParser.WITH, vbaParser.WITHEVENTS, vbaParser.WRITE, vbaParser.XOR]:
                        self.state = 2507
                        self.ambiguousKeyword()
                        pass
                    else:
                        raise NoViableAltException(self)


                else:
                    raise NoViableAltException(self)
                self.state = 2510 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,420,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 AsTypeClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


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

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

        def fieldLength(self):
            return self.getTypedRuleContext(vbaParser.FieldLengthContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_asTypeClause

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

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




    def asTypeClause(self):

        localctx = vbaParser.AsTypeClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_asTypeClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2512
            self.match(vbaParser.AS)
            self.state = 2514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2513
                self.match(vbaParser.WS)


            self.state = 2518
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,422,self._ctx)
            if la_ == 1:
                self.state = 2516
                self.match(vbaParser.NEW)
                self.state = 2517
                self.match(vbaParser.WS)


            self.state = 2520
            self.type_()
            self.state = 2525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,424,self._ctx)
            if la_ == 1:
                self.state = 2522
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2521
                    self.match(vbaParser.WS)


                self.state = 2524
                self.fieldLength()


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


    class BaseTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BOOLEAN(self):
            return self.getToken(vbaParser.BOOLEAN, 0)

        def BYTE(self):
            return self.getToken(vbaParser.BYTE, 0)

        def COLLECTION(self):
            return self.getToken(vbaParser.COLLECTION, 0)

        def DATE(self):
            return self.getToken(vbaParser.DATE, 0)

        def DOUBLE(self):
            return self.getToken(vbaParser.DOUBLE, 0)

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

        def LONG(self):
            return self.getToken(vbaParser.LONG, 0)

        def SINGLE(self):
            return self.getToken(vbaParser.SINGLE, 0)

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

        def MULT(self):
            return self.getToken(vbaParser.MULT, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


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

        def VARIANT(self):
            return self.getToken(vbaParser.VARIANT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_baseType

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

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




    def baseType(self):

        localctx = vbaParser.BaseTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_baseType)
        self._la = 0 # Token type
        try:
            self.state = 2547
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.BOOLEAN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2527
                self.match(vbaParser.BOOLEAN)
                pass
            elif token in [vbaParser.BYTE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2528
                self.match(vbaParser.BYTE)
                pass
            elif token in [vbaParser.COLLECTION]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2529
                self.match(vbaParser.COLLECTION)
                pass
            elif token in [vbaParser.DATE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2530
                self.match(vbaParser.DATE)
                pass
            elif token in [vbaParser.DOUBLE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2531
                self.match(vbaParser.DOUBLE)
                pass
            elif token in [vbaParser.INTEGER]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2532
                self.match(vbaParser.INTEGER)
                pass
            elif token in [vbaParser.LONG]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2533
                self.match(vbaParser.LONG)
                pass
            elif token in [vbaParser.SINGLE]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2534
                self.match(vbaParser.SINGLE)
                pass
            elif token in [vbaParser.STRING]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2535
                self.match(vbaParser.STRING)
                self.state = 2544
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
                if la_ == 1:
                    self.state = 2537
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2536
                        self.match(vbaParser.WS)


                    self.state = 2539
                    self.match(vbaParser.MULT)
                    self.state = 2541
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==vbaParser.WS:
                        self.state = 2540
                        self.match(vbaParser.WS)


                    self.state = 2543
                    self.valueStmt(0)


                pass
            elif token in [vbaParser.VARIANT]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2546
                self.match(vbaParser.VARIANT)
                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 CertainIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ambiguousKeyword(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousKeywordContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousKeywordContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_certainIdentifier

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

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




    def certainIdentifier(self):

        localctx = vbaParser.CertainIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_certainIdentifier)
        try:
            self.state = 2564
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2549
                self.match(vbaParser.IDENTIFIER)
                self.state = 2554
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,430,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2552
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [vbaParser.ACCESS, vbaParser.ADDRESSOF, vbaParser.ALIAS, vbaParser.AND, vbaParser.ATTRIBUTE, vbaParser.APPACTIVATE, vbaParser.APPEND, vbaParser.AS, vbaParser.BEGIN, vbaParser.BEEP, vbaParser.BINARY, vbaParser.BOOLEAN, vbaParser.BYVAL, vbaParser.BYREF, vbaParser.BYTE, vbaParser.CALL, vbaParser.CASE, vbaParser.CHDIR, vbaParser.CHDRIVE, vbaParser.CLASS, vbaParser.CLOSE, vbaParser.COLLECTION, vbaParser.CONST, vbaParser.DATABASE, vbaParser.DATE, vbaParser.DECLARE, vbaParser.DEFBOOL, vbaParser.DEFBYTE, vbaParser.DEFDATE, vbaParser.DEFDBL, vbaParser.DEFDEC, vbaParser.DEFCUR, vbaParser.DEFINT, vbaParser.DEFLNG, vbaParser.DEFOBJ, vbaParser.DEFSNG, vbaParser.DEFSTR, vbaParser.DEFVAR, vbaParser.DELETESETTING, vbaParser.DIM, vbaParser.DO, vbaParser.DOUBLE, vbaParser.EACH, vbaParser.ELSE, vbaParser.ELSEIF, vbaParser.END, vbaParser.ENUM, vbaParser.EQV, vbaParser.ERASE, vbaParser.ERROR, vbaParser.EVENT, vbaParser.FALSE, vbaParser.FILECOPY, vbaParser.FRIEND, vbaParser.FOR, vbaParser.FUNCTION, vbaParser.GET, vbaParser.GLOBAL, vbaParser.GOSUB, vbaParser.GOTO, vbaParser.IF, vbaParser.IMP, vbaParser.IMPLEMENTS, vbaParser.IN, vbaParser.INPUT, vbaParser.IS, vbaParser.INTEGER, vbaParser.KILL, vbaParser.LOAD, vbaParser.LOCK, vbaParser.LONG, vbaParser.LOOP, vbaParser.LEN, vbaParser.LET, vbaParser.LIB, vbaParser.LIKE, vbaParser.LSET, vbaParser.ME, vbaParser.MID, vbaParser.MKDIR, vbaParser.MOD, vbaParser.NAME, vbaParser.NEXT, vbaParser.NEW, vbaParser.NOT, vbaParser.NOTHING, vbaParser.NULL_, vbaParser.ON, vbaParser.OPEN, vbaParser.OPTIONAL, vbaParser.OR, vbaParser.OUTPUT, vbaParser.PARAMARRAY, vbaParser.PRESERVE, vbaParser.PRINT, vbaParser.PRIVATE, vbaParser.PUBLIC, vbaParser.PUT, vbaParser.RANDOM, vbaParser.RANDOMIZE, vbaParser.RAISEEVENT, vbaParser.READ, vbaParser.REDIM, vbaParser.REM, vbaParser.RESET, vbaParser.RESUME, vbaParser.RETURN, vbaParser.RMDIR, vbaParser.RSET, vbaParser.SAVEPICTURE, vbaParser.SAVESETTING, vbaParser.SEEK, vbaParser.SELECT, vbaParser.SENDKEYS, vbaParser.SET, vbaParser.SETATTR, vbaParser.SHARED, vbaParser.SINGLE, vbaParser.SPC, vbaParser.STATIC, vbaParser.STEP, vbaParser.STOP, vbaParser.STRING, vbaParser.SUB, vbaParser.TAB, vbaParser.TEXT, vbaParser.THEN, vbaParser.TIME, vbaParser.TO, vbaParser.TRUE, vbaParser.TYPE, vbaParser.TYPEOF, vbaParser.UNLOAD, vbaParser.UNLOCK, vbaParser.UNTIL, vbaParser.VARIANT, vbaParser.VERSION, vbaParser.WEND, vbaParser.WHILE, vbaParser.WIDTH, vbaParser.WITH, vbaParser.WITHEVENTS, vbaParser.WRITE, vbaParser.XOR]:
                            self.state = 2550
                            self.ambiguousKeyword()
                            pass
                        elif token in [vbaParser.IDENTIFIER]:
                            self.state = 2551
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 2556
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,430,self._ctx)

                pass
            elif token in [vbaParser.ACCESS, vbaParser.ADDRESSOF, vbaParser.ALIAS, vbaParser.AND, vbaParser.ATTRIBUTE, vbaParser.APPACTIVATE, vbaParser.APPEND, vbaParser.AS, vbaParser.BEGIN, vbaParser.BEEP, vbaParser.BINARY, vbaParser.BOOLEAN, vbaParser.BYVAL, vbaParser.BYREF, vbaParser.BYTE, vbaParser.CALL, vbaParser.CASE, vbaParser.CHDIR, vbaParser.CHDRIVE, vbaParser.CLASS, vbaParser.CLOSE, vbaParser.COLLECTION, vbaParser.CONST, vbaParser.DATABASE, vbaParser.DATE, vbaParser.DECLARE, vbaParser.DEFBOOL, vbaParser.DEFBYTE, vbaParser.DEFDATE, vbaParser.DEFDBL, vbaParser.DEFDEC, vbaParser.DEFCUR, vbaParser.DEFINT, vbaParser.DEFLNG, vbaParser.DEFOBJ, vbaParser.DEFSNG, vbaParser.DEFSTR, vbaParser.DEFVAR, vbaParser.DELETESETTING, vbaParser.DIM, vbaParser.DO, vbaParser.DOUBLE, vbaParser.EACH, vbaParser.ELSE, vbaParser.ELSEIF, vbaParser.END, vbaParser.ENUM, vbaParser.EQV, vbaParser.ERASE, vbaParser.ERROR, vbaParser.EVENT, vbaParser.FALSE, vbaParser.FILECOPY, vbaParser.FRIEND, vbaParser.FOR, vbaParser.FUNCTION, vbaParser.GET, vbaParser.GLOBAL, vbaParser.GOSUB, vbaParser.GOTO, vbaParser.IF, vbaParser.IMP, vbaParser.IMPLEMENTS, vbaParser.IN, vbaParser.INPUT, vbaParser.IS, vbaParser.INTEGER, vbaParser.KILL, vbaParser.LOAD, vbaParser.LOCK, vbaParser.LONG, vbaParser.LOOP, vbaParser.LEN, vbaParser.LET, vbaParser.LIB, vbaParser.LIKE, vbaParser.LSET, vbaParser.ME, vbaParser.MID, vbaParser.MKDIR, vbaParser.MOD, vbaParser.NAME, vbaParser.NEXT, vbaParser.NEW, vbaParser.NOT, vbaParser.NOTHING, vbaParser.NULL_, vbaParser.ON, vbaParser.OPEN, vbaParser.OPTIONAL, vbaParser.OR, vbaParser.OUTPUT, vbaParser.PARAMARRAY, vbaParser.PRESERVE, vbaParser.PRINT, vbaParser.PRIVATE, vbaParser.PUBLIC, vbaParser.PUT, vbaParser.RANDOM, vbaParser.RANDOMIZE, vbaParser.RAISEEVENT, vbaParser.READ, vbaParser.REDIM, vbaParser.REM, vbaParser.RESET, vbaParser.RESUME, vbaParser.RETURN, vbaParser.RMDIR, vbaParser.RSET, vbaParser.SAVEPICTURE, vbaParser.SAVESETTING, vbaParser.SEEK, vbaParser.SELECT, vbaParser.SENDKEYS, vbaParser.SET, vbaParser.SETATTR, vbaParser.SHARED, vbaParser.SINGLE, vbaParser.SPC, vbaParser.STATIC, vbaParser.STEP, vbaParser.STOP, vbaParser.STRING, vbaParser.SUB, vbaParser.TAB, vbaParser.TEXT, vbaParser.THEN, vbaParser.TIME, vbaParser.TO, vbaParser.TRUE, vbaParser.TYPE, vbaParser.TYPEOF, vbaParser.UNLOAD, vbaParser.UNLOCK, vbaParser.UNTIL, vbaParser.VARIANT, vbaParser.VERSION, vbaParser.WEND, vbaParser.WHILE, vbaParser.WIDTH, vbaParser.WITH, vbaParser.WITHEVENTS, vbaParser.WRITE, vbaParser.XOR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2557
                self.ambiguousKeyword()
                self.state = 2560 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2560
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [vbaParser.ACCESS, vbaParser.ADDRESSOF, vbaParser.ALIAS, vbaParser.AND, vbaParser.ATTRIBUTE, vbaParser.APPACTIVATE, vbaParser.APPEND, vbaParser.AS, vbaParser.BEGIN, vbaParser.BEEP, vbaParser.BINARY, vbaParser.BOOLEAN, vbaParser.BYVAL, vbaParser.BYREF, vbaParser.BYTE, vbaParser.CALL, vbaParser.CASE, vbaParser.CHDIR, vbaParser.CHDRIVE, vbaParser.CLASS, vbaParser.CLOSE, vbaParser.COLLECTION, vbaParser.CONST, vbaParser.DATABASE, vbaParser.DATE, vbaParser.DECLARE, vbaParser.DEFBOOL, vbaParser.DEFBYTE, vbaParser.DEFDATE, vbaParser.DEFDBL, vbaParser.DEFDEC, vbaParser.DEFCUR, vbaParser.DEFINT, vbaParser.DEFLNG, vbaParser.DEFOBJ, vbaParser.DEFSNG, vbaParser.DEFSTR, vbaParser.DEFVAR, vbaParser.DELETESETTING, vbaParser.DIM, vbaParser.DO, vbaParser.DOUBLE, vbaParser.EACH, vbaParser.ELSE, vbaParser.ELSEIF, vbaParser.END, vbaParser.ENUM, vbaParser.EQV, vbaParser.ERASE, vbaParser.ERROR, vbaParser.EVENT, vbaParser.FALSE, vbaParser.FILECOPY, vbaParser.FRIEND, vbaParser.FOR, vbaParser.FUNCTION, vbaParser.GET, vbaParser.GLOBAL, vbaParser.GOSUB, vbaParser.GOTO, vbaParser.IF, vbaParser.IMP, vbaParser.IMPLEMENTS, vbaParser.IN, vbaParser.INPUT, vbaParser.IS, vbaParser.INTEGER, vbaParser.KILL, vbaParser.LOAD, vbaParser.LOCK, vbaParser.LONG, vbaParser.LOOP, vbaParser.LEN, vbaParser.LET, vbaParser.LIB, vbaParser.LIKE, vbaParser.LSET, vbaParser.ME, vbaParser.MID, vbaParser.MKDIR, vbaParser.MOD, vbaParser.NAME, vbaParser.NEXT, vbaParser.NEW, vbaParser.NOT, vbaParser.NOTHING, vbaParser.NULL_, vbaParser.ON, vbaParser.OPEN, vbaParser.OPTIONAL, vbaParser.OR, vbaParser.OUTPUT, vbaParser.PARAMARRAY, vbaParser.PRESERVE, vbaParser.PRINT, vbaParser.PRIVATE, vbaParser.PUBLIC, vbaParser.PUT, vbaParser.RANDOM, vbaParser.RANDOMIZE, vbaParser.RAISEEVENT, vbaParser.READ, vbaParser.REDIM, vbaParser.REM, vbaParser.RESET, vbaParser.RESUME, vbaParser.RETURN, vbaParser.RMDIR, vbaParser.RSET, vbaParser.SAVEPICTURE, vbaParser.SAVESETTING, vbaParser.SEEK, vbaParser.SELECT, vbaParser.SENDKEYS, vbaParser.SET, vbaParser.SETATTR, vbaParser.SHARED, vbaParser.SINGLE, vbaParser.SPC, vbaParser.STATIC, vbaParser.STEP, vbaParser.STOP, vbaParser.STRING, vbaParser.SUB, vbaParser.TAB, vbaParser.TEXT, vbaParser.THEN, vbaParser.TIME, vbaParser.TO, vbaParser.TRUE, vbaParser.TYPE, vbaParser.TYPEOF, vbaParser.UNLOAD, vbaParser.UNLOCK, vbaParser.UNTIL, vbaParser.VARIANT, vbaParser.VERSION, vbaParser.WEND, vbaParser.WHILE, vbaParser.WIDTH, vbaParser.WITH, vbaParser.WITHEVENTS, vbaParser.WRITE, vbaParser.XOR]:
                            self.state = 2558
                            self.ambiguousKeyword()
                            pass
                        elif token in [vbaParser.IDENTIFIER]:
                            self.state = 2559
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)


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

                pass
            else:
                raise NoViableAltException(self)

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


    class ComparisonOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(vbaParser.LT, 0)

        def LEQ(self):
            return self.getToken(vbaParser.LEQ, 0)

        def GT(self):
            return self.getToken(vbaParser.GT, 0)

        def GEQ(self):
            return self.getToken(vbaParser.GEQ, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def NEQ(self):
            return self.getToken(vbaParser.NEQ, 0)

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

        def LIKE(self):
            return self.getToken(vbaParser.LIKE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_comparisonOperator

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

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




    def comparisonOperator(self):

        localctx = vbaParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2566
            _la = self._input.LA(1)
            if not(_la==vbaParser.IS or _la==vbaParser.LIKE or ((((_la - 189)) & ~0x3f) == 0 and ((1 << (_la - 189)) & ((1 << (vbaParser.EQ - 189)) | (1 << (vbaParser.GEQ - 189)) | (1 << (vbaParser.GT - 189)) | (1 << (vbaParser.LEQ - 189)) | (1 << (vbaParser.LT - 189)) | (1 << (vbaParser.NEQ - 189)))) != 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 ComplexTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousIdentifierContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_complexType

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

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




    def complexType(self):

        localctx = vbaParser.ComplexTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_complexType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2568
            self.ambiguousIdentifier()
            self.state = 2573
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,434,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2569
                    _la = self._input.LA(1)
                    if not(_la==vbaParser.T__3 or _la==vbaParser.T__4):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2570
                    self.ambiguousIdentifier() 
                self.state = 2575
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,434,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 FieldLengthContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MULT(self):
            return self.getToken(vbaParser.MULT, 0)

        def INTEGERLITERAL(self):
            return self.getToken(vbaParser.INTEGERLITERAL, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_fieldLength

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

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




    def fieldLength(self):

        localctx = vbaParser.FieldLengthContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_fieldLength)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2576
            self.match(vbaParser.MULT)
            self.state = 2578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2577
                self.match(vbaParser.WS)


            self.state = 2582
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.INTEGERLITERAL]:
                self.state = 2580
                self.match(vbaParser.INTEGERLITERAL)
                pass
            elif token in [vbaParser.ACCESS, vbaParser.ADDRESSOF, vbaParser.ALIAS, vbaParser.AND, vbaParser.ATTRIBUTE, vbaParser.APPACTIVATE, vbaParser.APPEND, vbaParser.AS, vbaParser.BEGIN, vbaParser.BEEP, vbaParser.BINARY, vbaParser.BOOLEAN, vbaParser.BYVAL, vbaParser.BYREF, vbaParser.BYTE, vbaParser.CALL, vbaParser.CASE, vbaParser.CHDIR, vbaParser.CHDRIVE, vbaParser.CLASS, vbaParser.CLOSE, vbaParser.COLLECTION, vbaParser.CONST, vbaParser.DATABASE, vbaParser.DATE, vbaParser.DECLARE, vbaParser.DEFBOOL, vbaParser.DEFBYTE, vbaParser.DEFDATE, vbaParser.DEFDBL, vbaParser.DEFDEC, vbaParser.DEFCUR, vbaParser.DEFINT, vbaParser.DEFLNG, vbaParser.DEFOBJ, vbaParser.DEFSNG, vbaParser.DEFSTR, vbaParser.DEFVAR, vbaParser.DELETESETTING, vbaParser.DIM, vbaParser.DO, vbaParser.DOUBLE, vbaParser.EACH, vbaParser.ELSE, vbaParser.ELSEIF, vbaParser.END, vbaParser.ENUM, vbaParser.EQV, vbaParser.ERASE, vbaParser.ERROR, vbaParser.EVENT, vbaParser.FALSE, vbaParser.FILECOPY, vbaParser.FRIEND, vbaParser.FOR, vbaParser.FUNCTION, vbaParser.GET, vbaParser.GLOBAL, vbaParser.GOSUB, vbaParser.GOTO, vbaParser.IF, vbaParser.IMP, vbaParser.IMPLEMENTS, vbaParser.IN, vbaParser.INPUT, vbaParser.IS, vbaParser.INTEGER, vbaParser.KILL, vbaParser.LOAD, vbaParser.LOCK, vbaParser.LONG, vbaParser.LOOP, vbaParser.LEN, vbaParser.LET, vbaParser.LIB, vbaParser.LIKE, vbaParser.LSET, vbaParser.ME, vbaParser.MID, vbaParser.MKDIR, vbaParser.MOD, vbaParser.NAME, vbaParser.NEXT, vbaParser.NEW, vbaParser.NOT, vbaParser.NOTHING, vbaParser.NULL_, vbaParser.ON, vbaParser.OPEN, vbaParser.OPTIONAL, vbaParser.OR, vbaParser.OUTPUT, vbaParser.PARAMARRAY, vbaParser.PRESERVE, vbaParser.PRINT, vbaParser.PRIVATE, vbaParser.PUBLIC, vbaParser.PUT, vbaParser.RANDOM, vbaParser.RANDOMIZE, vbaParser.RAISEEVENT, vbaParser.READ, vbaParser.REDIM, vbaParser.REM, vbaParser.RESET, vbaParser.RESUME, vbaParser.RETURN, vbaParser.RMDIR, vbaParser.RSET, vbaParser.SAVEPICTURE, vbaParser.SAVESETTING, vbaParser.SEEK, vbaParser.SELECT, vbaParser.SENDKEYS, vbaParser.SET, vbaParser.SETATTR, vbaParser.SHARED, vbaParser.SINGLE, vbaParser.SPC, vbaParser.STATIC, vbaParser.STEP, vbaParser.STOP, vbaParser.STRING, vbaParser.SUB, vbaParser.TAB, vbaParser.TEXT, vbaParser.THEN, vbaParser.TIME, vbaParser.TO, vbaParser.TRUE, vbaParser.TYPE, vbaParser.TYPEOF, vbaParser.UNLOAD, vbaParser.UNLOCK, vbaParser.UNTIL, vbaParser.VARIANT, vbaParser.VERSION, vbaParser.WEND, vbaParser.WHILE, vbaParser.WIDTH, vbaParser.WITH, vbaParser.WITHEVENTS, vbaParser.WRITE, vbaParser.XOR, vbaParser.IDENTIFIER]:
                self.state = 2581
                self.ambiguousIdentifier()
                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 LetterrangeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def certainIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.CertainIdentifierContext)
            else:
                return self.getTypedRuleContext(vbaParser.CertainIdentifierContext,i)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_letterrange

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

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




    def letterrange(self):

        localctx = vbaParser.LetterrangeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_letterrange)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2584
            self.certainIdentifier()
            self.state = 2593
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,439,self._ctx)
            if la_ == 1:
                self.state = 2586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2585
                    self.match(vbaParser.WS)


                self.state = 2588
                self.match(vbaParser.MINUS)
                self.state = 2590
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2589
                    self.match(vbaParser.WS)


                self.state = 2592
                self.certainIdentifier()


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


    class LineLabelContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


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

        def getRuleIndex(self):
            return vbaParser.RULE_lineLabel

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

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




    def lineLabel(self):

        localctx = vbaParser.LineLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_lineLabel)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2595
            self.ambiguousIdentifier()
            self.state = 2596
            self.match(vbaParser.COLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def HEXLITERAL(self):
            return self.getToken(vbaParser.HEXLITERAL, 0)

        def OCTLITERAL(self):
            return self.getToken(vbaParser.OCTLITERAL, 0)

        def DATELITERAL(self):
            return self.getToken(vbaParser.DATELITERAL, 0)

        def DOUBLELITERAL(self):
            return self.getToken(vbaParser.DOUBLELITERAL, 0)

        def INTEGERLITERAL(self):
            return self.getToken(vbaParser.INTEGERLITERAL, 0)

        def SHORTLITERAL(self):
            return self.getToken(vbaParser.SHORTLITERAL, 0)

        def STRINGLITERAL(self):
            return self.getToken(vbaParser.STRINGLITERAL, 0)

        def TRUE(self):
            return self.getToken(vbaParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(vbaParser.FALSE, 0)

        def NOTHING(self):
            return self.getToken(vbaParser.NOTHING, 0)

        def NULL_(self):
            return self.getToken(vbaParser.NULL_, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_literal

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

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




    def literal(self):

        localctx = vbaParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2598
            _la = self._input.LA(1)
            if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (vbaParser.FALSE - 73)) | (1 << (vbaParser.NOTHING - 73)) | (1 << (vbaParser.NULL_ - 73)))) != 0) or ((((_la - 171)) & ~0x3f) == 0 and ((1 << (_la - 171)) & ((1 << (vbaParser.TRUE - 171)) | (1 << (vbaParser.STRINGLITERAL - 171)) | (1 << (vbaParser.OCTLITERAL - 171)) | (1 << (vbaParser.HEXLITERAL - 171)) | (1 << (vbaParser.SHORTLITERAL - 171)) | (1 << (vbaParser.INTEGERLITERAL - 171)) | (1 << (vbaParser.DOUBLELITERAL - 171)) | (1 << (vbaParser.DATELITERAL - 171)))) != 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 Type_Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def baseType(self):
            return self.getTypedRuleContext(vbaParser.BaseTypeContext,0)


        def complexType(self):
            return self.getTypedRuleContext(vbaParser.ComplexTypeContext,0)


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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_type_

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

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




    def type_(self):

        localctx = vbaParser.Type_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_type_)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2602
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,440,self._ctx)
            if la_ == 1:
                self.state = 2600
                self.baseType()
                pass

            elif la_ == 2:
                self.state = 2601
                self.complexType()
                pass


            self.state = 2612
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,443,self._ctx)
            if la_ == 1:
                self.state = 2605
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2604
                    self.match(vbaParser.WS)


                self.state = 2607
                self.match(vbaParser.LPAREN)
                self.state = 2609
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==vbaParser.WS:
                    self.state = 2608
                    self.match(vbaParser.WS)


                self.state = 2611
                self.match(vbaParser.RPAREN)


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


    class TypeHintContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_typeHint

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

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




    def typeHint(self):

        localctx = vbaParser.TypeHintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_typeHint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2614
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.T__2) | (1 << vbaParser.T__4) | (1 << vbaParser.T__5) | (1 << vbaParser.T__6) | (1 << vbaParser.T__7))) != 0) or _la==vbaParser.AMPERSAND):
                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 VisibilityContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PRIVATE(self):
            return self.getToken(vbaParser.PRIVATE, 0)

        def PUBLIC(self):
            return self.getToken(vbaParser.PUBLIC, 0)

        def FRIEND(self):
            return self.getToken(vbaParser.FRIEND, 0)

        def GLOBAL(self):
            return self.getToken(vbaParser.GLOBAL, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_visibility

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

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




    def visibility(self):

        localctx = vbaParser.VisibilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2616
            _la = self._input.LA(1)
            if not(((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (vbaParser.FRIEND - 75)) | (1 << (vbaParser.GLOBAL - 75)) | (1 << (vbaParser.PRIVATE - 75)) | (1 << (vbaParser.PUBLIC - 75)))) != 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 AmbiguousKeywordContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ADDRESSOF(self):
            return self.getToken(vbaParser.ADDRESSOF, 0)

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

        def AND(self):
            return self.getToken(vbaParser.AND, 0)

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

        def APPACTIVATE(self):
            return self.getToken(vbaParser.APPACTIVATE, 0)

        def APPEND(self):
            return self.getToken(vbaParser.APPEND, 0)

        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def BEEP(self):
            return self.getToken(vbaParser.BEEP, 0)

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

        def BINARY(self):
            return self.getToken(vbaParser.BINARY, 0)

        def BOOLEAN(self):
            return self.getToken(vbaParser.BOOLEAN, 0)

        def BYVAL(self):
            return self.getToken(vbaParser.BYVAL, 0)

        def BYREF(self):
            return self.getToken(vbaParser.BYREF, 0)

        def BYTE(self):
            return self.getToken(vbaParser.BYTE, 0)

        def CALL(self):
            return self.getToken(vbaParser.CALL, 0)

        def CASE(self):
            return self.getToken(vbaParser.CASE, 0)

        def CLASS(self):
            return self.getToken(vbaParser.CLASS, 0)

        def CLOSE(self):
            return self.getToken(vbaParser.CLOSE, 0)

        def CHDIR(self):
            return self.getToken(vbaParser.CHDIR, 0)

        def CHDRIVE(self):
            return self.getToken(vbaParser.CHDRIVE, 0)

        def COLLECTION(self):
            return self.getToken(vbaParser.COLLECTION, 0)

        def CONST(self):
            return self.getToken(vbaParser.CONST, 0)

        def DATABASE(self):
            return self.getToken(vbaParser.DATABASE, 0)

        def DATE(self):
            return self.getToken(vbaParser.DATE, 0)

        def DECLARE(self):
            return self.getToken(vbaParser.DECLARE, 0)

        def DEFBOOL(self):
            return self.getToken(vbaParser.DEFBOOL, 0)

        def DEFBYTE(self):
            return self.getToken(vbaParser.DEFBYTE, 0)

        def DEFCUR(self):
            return self.getToken(vbaParser.DEFCUR, 0)

        def DEFDBL(self):
            return self.getToken(vbaParser.DEFDBL, 0)

        def DEFDATE(self):
            return self.getToken(vbaParser.DEFDATE, 0)

        def DEFDEC(self):
            return self.getToken(vbaParser.DEFDEC, 0)

        def DEFINT(self):
            return self.getToken(vbaParser.DEFINT, 0)

        def DEFLNG(self):
            return self.getToken(vbaParser.DEFLNG, 0)

        def DEFOBJ(self):
            return self.getToken(vbaParser.DEFOBJ, 0)

        def DEFSNG(self):
            return self.getToken(vbaParser.DEFSNG, 0)

        def DEFSTR(self):
            return self.getToken(vbaParser.DEFSTR, 0)

        def DEFVAR(self):
            return self.getToken(vbaParser.DEFVAR, 0)

        def DELETESETTING(self):
            return self.getToken(vbaParser.DELETESETTING, 0)

        def DIM(self):
            return self.getToken(vbaParser.DIM, 0)

        def DO(self):
            return self.getToken(vbaParser.DO, 0)

        def DOUBLE(self):
            return self.getToken(vbaParser.DOUBLE, 0)

        def EACH(self):
            return self.getToken(vbaParser.EACH, 0)

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

        def ELSEIF(self):
            return self.getToken(vbaParser.ELSEIF, 0)

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

        def ENUM(self):
            return self.getToken(vbaParser.ENUM, 0)

        def EQV(self):
            return self.getToken(vbaParser.EQV, 0)

        def ERASE(self):
            return self.getToken(vbaParser.ERASE, 0)

        def ERROR(self):
            return self.getToken(vbaParser.ERROR, 0)

        def EVENT(self):
            return self.getToken(vbaParser.EVENT, 0)

        def FALSE(self):
            return self.getToken(vbaParser.FALSE, 0)

        def FILECOPY(self):
            return self.getToken(vbaParser.FILECOPY, 0)

        def FRIEND(self):
            return self.getToken(vbaParser.FRIEND, 0)

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

        def FUNCTION(self):
            return self.getToken(vbaParser.FUNCTION, 0)

        def GET(self):
            return self.getToken(vbaParser.GET, 0)

        def GLOBAL(self):
            return self.getToken(vbaParser.GLOBAL, 0)

        def GOSUB(self):
            return self.getToken(vbaParser.GOSUB, 0)

        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def IF(self):
            return self.getToken(vbaParser.IF, 0)

        def IMP(self):
            return self.getToken(vbaParser.IMP, 0)

        def IMPLEMENTS(self):
            return self.getToken(vbaParser.IMPLEMENTS, 0)

        def IN(self):
            return self.getToken(vbaParser.IN, 0)

        def INPUT(self):
            return self.getToken(vbaParser.INPUT, 0)

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

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

        def KILL(self):
            return self.getToken(vbaParser.KILL, 0)

        def LOAD(self):
            return self.getToken(vbaParser.LOAD, 0)

        def LOCK(self):
            return self.getToken(vbaParser.LOCK, 0)

        def LONG(self):
            return self.getToken(vbaParser.LONG, 0)

        def LOOP(self):
            return self.getToken(vbaParser.LOOP, 0)

        def LEN(self):
            return self.getToken(vbaParser.LEN, 0)

        def LET(self):
            return self.getToken(vbaParser.LET, 0)

        def LIB(self):
            return self.getToken(vbaParser.LIB, 0)

        def LIKE(self):
            return self.getToken(vbaParser.LIKE, 0)

        def LSET(self):
            return self.getToken(vbaParser.LSET, 0)

        def ME(self):
            return self.getToken(vbaParser.ME, 0)

        def MID(self):
            return self.getToken(vbaParser.MID, 0)

        def MKDIR(self):
            return self.getToken(vbaParser.MKDIR, 0)

        def MOD(self):
            return self.getToken(vbaParser.MOD, 0)

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

        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

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

        def NOT(self):
            return self.getToken(vbaParser.NOT, 0)

        def NOTHING(self):
            return self.getToken(vbaParser.NOTHING, 0)

        def NULL_(self):
            return self.getToken(vbaParser.NULL_, 0)

        def ON(self):
            return self.getToken(vbaParser.ON, 0)

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

        def OPTIONAL(self):
            return self.getToken(vbaParser.OPTIONAL, 0)

        def OR(self):
            return self.getToken(vbaParser.OR, 0)

        def OUTPUT(self):
            return self.getToken(vbaParser.OUTPUT, 0)

        def PARAMARRAY(self):
            return self.getToken(vbaParser.PARAMARRAY, 0)

        def PRESERVE(self):
            return self.getToken(vbaParser.PRESERVE, 0)

        def PRINT(self):
            return self.getToken(vbaParser.PRINT, 0)

        def PRIVATE(self):
            return self.getToken(vbaParser.PRIVATE, 0)

        def PUBLIC(self):
            return self.getToken(vbaParser.PUBLIC, 0)

        def PUT(self):
            return self.getToken(vbaParser.PUT, 0)

        def RANDOM(self):
            return self.getToken(vbaParser.RANDOM, 0)

        def RANDOMIZE(self):
            return self.getToken(vbaParser.RANDOMIZE, 0)

        def RAISEEVENT(self):
            return self.getToken(vbaParser.RAISEEVENT, 0)

        def READ(self):
            return self.getToken(vbaParser.READ, 0)

        def REDIM(self):
            return self.getToken(vbaParser.REDIM, 0)

        def REM(self):
            return self.getToken(vbaParser.REM, 0)

        def RESET(self):
            return self.getToken(vbaParser.RESET, 0)

        def RESUME(self):
            return self.getToken(vbaParser.RESUME, 0)

        def RETURN(self):
            return self.getToken(vbaParser.RETURN, 0)

        def RMDIR(self):
            return self.getToken(vbaParser.RMDIR, 0)

        def RSET(self):
            return self.getToken(vbaParser.RSET, 0)

        def SAVEPICTURE(self):
            return self.getToken(vbaParser.SAVEPICTURE, 0)

        def SAVESETTING(self):
            return self.getToken(vbaParser.SAVESETTING, 0)

        def SEEK(self):
            return self.getToken(vbaParser.SEEK, 0)

        def SELECT(self):
            return self.getToken(vbaParser.SELECT, 0)

        def SENDKEYS(self):
            return self.getToken(vbaParser.SENDKEYS, 0)

        def SET(self):
            return self.getToken(vbaParser.SET, 0)

        def SETATTR(self):
            return self.getToken(vbaParser.SETATTR, 0)

        def SHARED(self):
            return self.getToken(vbaParser.SHARED, 0)

        def SINGLE(self):
            return self.getToken(vbaParser.SINGLE, 0)

        def SPC(self):
            return self.getToken(vbaParser.SPC, 0)

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def STEP(self):
            return self.getToken(vbaParser.STEP, 0)

        def STOP(self):
            return self.getToken(vbaParser.STOP, 0)

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

        def SUB(self):
            return self.getToken(vbaParser.SUB, 0)

        def TAB(self):
            return self.getToken(vbaParser.TAB, 0)

        def TEXT(self):
            return self.getToken(vbaParser.TEXT, 0)

        def THEN(self):
            return self.getToken(vbaParser.THEN, 0)

        def TIME(self):
            return self.getToken(vbaParser.TIME, 0)

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

        def TRUE(self):
            return self.getToken(vbaParser.TRUE, 0)

        def TYPE(self):
            return self.getToken(vbaParser.TYPE, 0)

        def TYPEOF(self):
            return self.getToken(vbaParser.TYPEOF, 0)

        def UNLOAD(self):
            return self.getToken(vbaParser.UNLOAD, 0)

        def UNLOCK(self):
            return self.getToken(vbaParser.UNLOCK, 0)

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

        def VARIANT(self):
            return self.getToken(vbaParser.VARIANT, 0)

        def VERSION(self):
            return self.getToken(vbaParser.VERSION, 0)

        def WEND(self):
            return self.getToken(vbaParser.WEND, 0)

        def WHILE(self):
            return self.getToken(vbaParser.WHILE, 0)

        def WIDTH(self):
            return self.getToken(vbaParser.WIDTH, 0)

        def WITH(self):
            return self.getToken(vbaParser.WITH, 0)

        def WITHEVENTS(self):
            return self.getToken(vbaParser.WITHEVENTS, 0)

        def WRITE(self):
            return self.getToken(vbaParser.WRITE, 0)

        def XOR(self):
            return self.getToken(vbaParser.XOR, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_ambiguousKeyword

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

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




    def ambiguousKeyword(self):

        localctx = vbaParser.AmbiguousKeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_ambiguousKeyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2618
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << vbaParser.ACCESS) | (1 << vbaParser.ADDRESSOF) | (1 << vbaParser.ALIAS) | (1 << vbaParser.AND) | (1 << vbaParser.ATTRIBUTE) | (1 << vbaParser.APPACTIVATE) | (1 << vbaParser.APPEND) | (1 << vbaParser.AS) | (1 << vbaParser.BEGIN) | (1 << vbaParser.BEEP) | (1 << vbaParser.BINARY) | (1 << vbaParser.BOOLEAN) | (1 << vbaParser.BYVAL) | (1 << vbaParser.BYREF) | (1 << vbaParser.BYTE) | (1 << vbaParser.CALL) | (1 << vbaParser.CASE) | (1 << vbaParser.CHDIR) | (1 << vbaParser.CHDRIVE) | (1 << vbaParser.CLASS) | (1 << vbaParser.CLOSE) | (1 << vbaParser.COLLECTION) | (1 << vbaParser.CONST) | (1 << vbaParser.DATABASE) | (1 << vbaParser.DATE) | (1 << vbaParser.DECLARE) | (1 << vbaParser.DEFBOOL) | (1 << vbaParser.DEFBYTE) | (1 << vbaParser.DEFDATE) | (1 << vbaParser.DEFDBL) | (1 << vbaParser.DEFDEC) | (1 << vbaParser.DEFCUR) | (1 << vbaParser.DEFINT) | (1 << vbaParser.DEFLNG) | (1 << vbaParser.DEFOBJ) | (1 << vbaParser.DEFSNG) | (1 << vbaParser.DEFSTR) | (1 << vbaParser.DEFVAR) | (1 << vbaParser.DELETESETTING) | (1 << vbaParser.DIM) | (1 << vbaParser.DO) | (1 << vbaParser.DOUBLE) | (1 << vbaParser.EACH) | (1 << vbaParser.ELSE) | (1 << vbaParser.ELSEIF) | (1 << vbaParser.END) | (1 << vbaParser.ENUM))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (vbaParser.EQV - 64)) | (1 << (vbaParser.ERASE - 64)) | (1 << (vbaParser.ERROR - 64)) | (1 << (vbaParser.EVENT - 64)) | (1 << (vbaParser.FALSE - 64)) | (1 << (vbaParser.FILECOPY - 64)) | (1 << (vbaParser.FRIEND - 64)) | (1 << (vbaParser.FOR - 64)) | (1 << (vbaParser.FUNCTION - 64)) | (1 << (vbaParser.GET - 64)) | (1 << (vbaParser.GLOBAL - 64)) | (1 << (vbaParser.GOSUB - 64)) | (1 << (vbaParser.GOTO - 64)) | (1 << (vbaParser.IF - 64)) | (1 << (vbaParser.IMP - 64)) | (1 << (vbaParser.IMPLEMENTS - 64)) | (1 << (vbaParser.IN - 64)) | (1 << (vbaParser.INPUT - 64)) | (1 << (vbaParser.IS - 64)) | (1 << (vbaParser.INTEGER - 64)) | (1 << (vbaParser.KILL - 64)) | (1 << (vbaParser.LOAD - 64)) | (1 << (vbaParser.LOCK - 64)) | (1 << (vbaParser.LONG - 64)) | (1 << (vbaParser.LOOP - 64)) | (1 << (vbaParser.LEN - 64)) | (1 << (vbaParser.LET - 64)) | (1 << (vbaParser.LIB - 64)) | (1 << (vbaParser.LIKE - 64)) | (1 << (vbaParser.LSET - 64)) | (1 << (vbaParser.ME - 64)) | (1 << (vbaParser.MID - 64)) | (1 << (vbaParser.MKDIR - 64)) | (1 << (vbaParser.MOD - 64)) | (1 << (vbaParser.NAME - 64)) | (1 << (vbaParser.NEXT - 64)) | (1 << (vbaParser.NEW - 64)) | (1 << (vbaParser.NOT - 64)) | (1 << (vbaParser.NOTHING - 64)) | (1 << (vbaParser.NULL_ - 64)) | (1 << (vbaParser.ON - 64)) | (1 << (vbaParser.OPEN - 64)) | (1 << (vbaParser.OPTIONAL - 64)) | (1 << (vbaParser.OR - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (vbaParser.OUTPUT - 128)) | (1 << (vbaParser.PARAMARRAY - 128)) | (1 << (vbaParser.PRESERVE - 128)) | (1 << (vbaParser.PRINT - 128)) | (1 << (vbaParser.PRIVATE - 128)) | (1 << (vbaParser.PUBLIC - 128)) | (1 << (vbaParser.PUT - 128)) | (1 << (vbaParser.RANDOM - 128)) | (1 << (vbaParser.RANDOMIZE - 128)) | (1 << (vbaParser.RAISEEVENT - 128)) | (1 << (vbaParser.READ - 128)) | (1 << (vbaParser.REDIM - 128)) | (1 << (vbaParser.REM - 128)) | (1 << (vbaParser.RESET - 128)) | (1 << (vbaParser.RESUME - 128)) | (1 << (vbaParser.RETURN - 128)) | (1 << (vbaParser.RMDIR - 128)) | (1 << (vbaParser.RSET - 128)) | (1 << (vbaParser.SAVEPICTURE - 128)) | (1 << (vbaParser.SAVESETTING - 128)) | (1 << (vbaParser.SEEK - 128)) | (1 << (vbaParser.SELECT - 128)) | (1 << (vbaParser.SENDKEYS - 128)) | (1 << (vbaParser.SET - 128)) | (1 << (vbaParser.SETATTR - 128)) | (1 << (vbaParser.SHARED - 128)) | (1 << (vbaParser.SINGLE - 128)) | (1 << (vbaParser.SPC - 128)) | (1 << (vbaParser.STATIC - 128)) | (1 << (vbaParser.STEP - 128)) | (1 << (vbaParser.STOP - 128)) | (1 << (vbaParser.STRING - 128)) | (1 << (vbaParser.SUB - 128)) | (1 << (vbaParser.TAB - 128)) | (1 << (vbaParser.TEXT - 128)) | (1 << (vbaParser.THEN - 128)) | (1 << (vbaParser.TIME - 128)) | (1 << (vbaParser.TO - 128)) | (1 << (vbaParser.TRUE - 128)) | (1 << (vbaParser.TYPE - 128)) | (1 << (vbaParser.TYPEOF - 128)) | (1 << (vbaParser.UNLOAD - 128)) | (1 << (vbaParser.UNLOCK - 128)) | (1 << (vbaParser.UNTIL - 128)) | (1 << (vbaParser.VARIANT - 128)) | (1 << (vbaParser.VERSION - 128)) | (1 << (vbaParser.WEND - 128)) | (1 << (vbaParser.WHILE - 128)) | (1 << (vbaParser.WIDTH - 128)) | (1 << (vbaParser.WITH - 128)) | (1 << (vbaParser.WITHEVENTS - 128)) | (1 << (vbaParser.WRITE - 128)) | (1 << (vbaParser.XOR - 128)))) != 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 RemCommentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REMCOMMENT(self):
            return self.getToken(vbaParser.REMCOMMENT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_remComment

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

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




    def remComment(self):

        localctx = vbaParser.RemCommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_remComment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2620
            self.match(vbaParser.REMCOMMENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def COMMENT(self):
            return self.getToken(vbaParser.COMMENT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_comment

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

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




    def comment(self):

        localctx = vbaParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_comment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2622
            self.match(vbaParser.COMMENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EndOfLineContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def comment(self):
            return self.getTypedRuleContext(vbaParser.CommentContext,0)


        def remComment(self):
            return self.getTypedRuleContext(vbaParser.RemCommentContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_endOfLine

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEndOfLine" ):
                listener.enterEndOfLine(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEndOfLine" ):
                listener.exitEndOfLine(self)




    def endOfLine(self):

        localctx = vbaParser.EndOfLineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_endOfLine)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2625
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==vbaParser.WS:
                self.state = 2624
                self.match(vbaParser.WS)


            self.state = 2630
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [vbaParser.NEWLINE]:
                self.state = 2627
                self.match(vbaParser.NEWLINE)
                pass
            elif token in [vbaParser.COMMENT]:
                self.state = 2628
                self.comment()
                pass
            elif token in [vbaParser.REMCOMMENT]:
                self.state = 2629
                self.remComment()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2633
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,446,self._ctx)
            if la_ == 1:
                self.state = 2632
                self.match(vbaParser.WS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EndOfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.COLON)
            else:
                return self.getToken(vbaParser.COLON, i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_endOfStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEndOfStatement" ):
                listener.enterEndOfStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEndOfStatement" ):
                listener.exitEndOfStatement(self)




    def endOfStatement(self):

        localctx = vbaParser.EndOfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_endOfStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2645
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,450,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2643
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,449,self._ctx)
                    if la_ == 1:
                        self.state = 2635
                        self.endOfLine()
                        pass

                    elif la_ == 2:
                        self.state = 2637
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==vbaParser.WS:
                            self.state = 2636
                            self.match(vbaParser.WS)


                        self.state = 2639
                        self.match(vbaParser.COLON)
                        self.state = 2641
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,448,self._ctx)
                        if la_ == 1:
                            self.state = 2640
                            self.match(vbaParser.WS)


                        pass

             
                self.state = 2647
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,450,self._ctx)

        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[100] = self.valueStmt_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 valueStmt_sempred(self, localctx:ValueStmtContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 23)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 22)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 21)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 20)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 19)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 18)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 18:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 19:
                return self.precpred(self._ctx, 2)
         




