# Generated from vba.g4 by ANTLR 4.13.1
# 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():
    return [
        4,1,220,2590,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        1,0,1,0,1,0,1,1,3,1,301,8,1,1,1,5,1,304,8,1,10,1,12,1,307,9,1,1,
        1,1,1,5,1,311,8,1,10,1,12,1,314,9,1,3,1,316,8,1,1,1,3,1,319,8,1,
        1,1,5,1,322,8,1,10,1,12,1,325,9,1,1,1,3,1,328,8,1,1,1,5,1,331,8,
        1,10,1,12,1,334,9,1,1,1,3,1,337,8,1,1,1,5,1,340,8,1,10,1,12,1,343,
        9,1,1,1,3,1,346,8,1,1,1,5,1,349,8,1,10,1,12,1,352,9,1,1,1,3,1,355,
        8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,5,3,365,8,3,10,3,12,3,368,9,
        3,1,3,4,3,371,8,3,11,3,12,3,372,1,3,1,3,1,4,1,4,3,4,379,8,4,1,4,
        1,4,3,4,383,8,4,1,4,1,4,5,4,387,8,4,10,4,12,4,390,9,4,1,5,1,5,4,
        5,394,8,5,11,5,12,5,395,4,5,398,8,5,11,5,12,5,399,1,6,1,6,4,6,404,
        8,6,11,6,12,6,405,1,6,1,6,5,6,410,8,6,10,6,12,6,413,9,6,1,6,5,6,
        416,8,6,10,6,12,6,419,9,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,3,7,429,
        8,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,442,8,8,1,9,
        1,9,3,9,446,8,9,1,10,1,10,4,10,450,8,10,11,10,12,10,451,1,10,1,10,
        5,10,456,8,10,10,10,12,10,459,9,10,1,10,5,10,462,8,10,10,10,12,10,
        465,9,10,1,11,1,11,1,11,1,11,1,11,1,11,3,11,473,8,11,1,12,1,12,1,
        12,1,12,3,12,479,8,12,1,12,1,12,3,12,483,8,12,1,12,1,12,3,12,487,
        8,12,1,12,1,12,3,12,491,8,12,1,12,5,12,494,8,12,10,12,12,12,497,
        9,12,1,13,1,13,1,13,1,13,5,13,503,8,13,10,13,12,13,506,9,13,1,13,
        1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
        1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
        1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
        1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
        1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
        1,14,1,14,1,14,1,14,3,14,578,8,14,1,15,1,15,1,15,1,15,3,15,584,8,
        15,1,15,1,15,3,15,588,8,15,1,15,3,15,591,8,15,1,16,1,16,1,17,1,17,
        1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,3,19,607,8,19,
        1,19,1,19,3,19,611,8,19,1,19,5,19,614,8,19,10,19,12,19,617,9,19,
        3,19,619,8,19,1,20,1,20,1,20,3,20,624,8,20,1,20,1,20,1,20,1,20,3,
        20,630,8,20,1,20,1,20,3,20,634,8,20,1,20,5,20,637,8,20,10,20,12,
        20,640,9,20,1,21,1,21,3,21,644,8,21,1,21,1,21,3,21,648,8,21,1,21,
        3,21,651,8,21,1,21,1,21,3,21,655,8,21,1,21,1,21,1,22,1,22,3,22,661,
        8,22,1,22,1,22,3,22,665,8,22,1,22,1,22,1,23,1,23,1,23,3,23,672,8,
        23,1,23,1,23,1,23,1,23,3,23,678,8,23,1,23,1,23,3,23,682,8,23,1,23,
        3,23,685,8,23,1,23,1,23,1,23,3,23,690,8,23,1,23,1,23,1,23,1,23,1,
        23,1,23,1,23,1,23,3,23,700,8,23,1,23,3,23,703,8,23,1,23,3,23,706,
        8,23,1,23,1,23,3,23,710,8,23,1,24,1,24,1,24,1,24,3,24,716,8,24,1,
        24,1,24,3,24,720,8,24,1,24,5,24,723,8,24,10,24,12,24,726,9,24,1,
        25,1,25,1,25,1,25,3,25,732,8,25,1,25,1,25,3,25,736,8,25,1,25,1,25,
        3,25,740,8,25,1,25,1,25,3,25,744,8,25,1,25,3,25,747,8,25,1,26,1,
        26,1,26,3,26,752,8,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,
        26,3,26,763,8,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,
        26,1,26,3,26,776,8,26,1,27,1,27,1,28,1,28,1,28,3,28,783,8,28,1,28,
        1,28,1,28,1,28,1,28,5,28,790,8,28,10,28,12,28,793,9,28,1,28,1,28,
        1,29,1,29,3,29,799,8,29,1,29,1,29,3,29,803,8,29,1,29,3,29,806,8,
        29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,3,30,815,8,30,1,30,5,30,818,
        8,30,10,30,12,30,821,9,30,1,31,1,31,1,31,1,31,1,32,1,32,1,32,3,32,
        830,8,32,1,32,1,32,1,32,1,32,3,32,836,8,32,1,32,1,32,1,33,1,33,1,
        34,1,34,1,34,1,34,3,34,846,8,34,1,34,1,34,3,34,850,8,34,1,34,1,34,
        1,35,1,35,1,35,1,35,1,35,1,35,3,35,860,8,35,1,35,1,35,1,35,1,35,
        1,35,1,35,3,35,868,8,35,1,35,1,35,1,35,3,35,873,8,35,1,36,1,36,1,
        36,1,36,3,36,879,8,36,1,36,1,36,3,36,883,8,36,1,36,3,36,886,8,36,
        1,36,1,36,3,36,890,8,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,
        1,36,3,36,901,8,36,1,36,1,36,3,36,905,8,36,1,36,1,36,1,36,3,36,910,
        8,36,1,37,1,37,1,37,3,37,915,8,37,1,37,1,37,3,37,919,8,37,1,37,1,
        37,3,37,923,8,37,1,37,1,37,3,37,927,8,37,1,37,3,37,930,8,37,1,37,
        3,37,933,8,37,1,37,3,37,936,8,37,1,37,3,37,939,8,37,1,37,1,37,3,
        37,943,8,37,1,37,1,37,1,38,1,38,1,38,1,38,3,38,951,8,38,1,38,1,38,
        3,38,955,8,38,1,38,3,38,958,8,38,1,38,3,38,961,8,38,1,38,1,38,3,
        38,965,8,38,1,38,1,38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,
        41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,3,41,988,8,
        41,1,41,1,41,5,41,992,8,41,10,41,12,41,995,9,41,1,41,3,41,998,8,
        41,1,41,1,41,3,41,1002,8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,
        42,1011,8,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,1022,
        8,44,1,45,1,45,1,45,3,45,1027,8,45,1,46,1,46,1,46,1,46,1,47,1,47,
        1,47,1,47,3,47,1037,8,47,1,47,1,47,3,47,1041,8,47,1,47,4,47,1044,
        8,47,11,47,12,47,1045,1,48,1,48,1,48,1,48,1,49,1,49,3,49,1054,8,
        49,1,49,1,49,3,49,1058,8,49,1,49,1,49,3,49,1062,8,49,1,49,1,49,1,
        50,1,50,1,50,1,50,3,50,1070,8,50,1,50,1,50,3,50,1074,8,50,1,50,1,
        50,1,51,1,51,3,51,1080,8,51,1,51,3,51,1083,8,51,1,51,3,51,1086,8,
        51,1,51,3,51,1089,8,51,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,3,
        53,1099,8,53,1,53,1,53,3,53,1103,8,53,1,53,1,53,1,53,1,53,1,53,3,
        53,1110,8,53,3,53,1112,8,53,1,54,1,54,1,54,1,54,3,54,1118,8,54,1,
        54,1,54,3,54,1122,8,54,1,54,1,54,1,55,1,55,3,55,1128,8,55,1,55,1,
        55,3,55,1132,8,55,1,55,1,55,3,55,1136,8,55,1,55,1,55,1,56,1,56,5,
        56,1142,8,56,10,56,12,56,1145,9,56,1,56,3,56,1148,8,56,1,56,1,56,
        1,57,1,57,3,57,1154,8,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,5,57,
        1163,8,57,10,57,12,57,1166,9,57,1,58,1,58,3,58,1170,8,58,1,58,1,
        58,1,58,1,58,1,58,1,58,1,58,5,58,1179,8,58,10,58,12,58,1182,9,58,
        1,59,1,59,1,59,1,59,1,59,5,59,1189,8,59,10,59,12,59,1192,9,59,1,
        60,1,60,3,60,1196,8,60,1,60,1,60,3,60,1200,8,60,1,60,1,60,3,60,1204,
        8,60,1,60,1,60,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,
        1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,3,63,1228,8,63,
        1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,3,64,1238,8,64,1,64,1,64,
        3,64,1242,8,64,1,64,5,64,1245,8,64,10,64,12,64,1248,9,64,1,65,1,
        65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1258,8,65,1,65,1,65,3,65,1262,
        8,65,1,65,5,65,1265,8,65,10,65,12,65,1268,9,65,1,66,1,66,1,66,1,
        66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1281,8,66,1,66,1,66,3,
        66,1285,8,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1294,8,66,1,
        66,1,66,3,66,1298,8,66,1,66,3,66,1301,8,66,1,67,1,67,3,67,1305,8,
        67,1,67,1,67,3,67,1309,8,67,1,67,3,67,1312,8,67,5,67,1314,8,67,10,
        67,12,67,1317,9,67,1,67,3,67,1320,8,67,1,67,3,67,1323,8,67,1,67,
        1,67,3,67,1327,8,67,1,67,3,67,1330,8,67,4,67,1332,8,67,11,67,12,
        67,1333,3,67,1336,8,67,1,68,1,68,1,68,3,68,1341,8,68,1,68,1,68,3,
        68,1345,8,68,1,68,1,68,3,68,1349,8,68,1,68,1,68,3,68,1353,8,68,3,
        68,1355,8,68,1,69,1,69,1,69,1,69,3,69,1361,8,69,1,69,1,69,3,69,1365,
        8,69,1,69,3,69,1368,8,69,1,70,1,70,1,70,3,70,1373,8,70,1,70,1,70,
        3,70,1377,8,70,1,70,1,70,1,70,1,70,3,70,1383,8,70,1,70,3,70,1386,
        8,70,1,70,3,70,1389,8,70,1,70,1,70,3,70,1393,8,70,1,70,1,70,3,70,
        1397,8,70,1,70,1,70,1,71,1,71,1,71,3,71,1404,8,71,1,71,1,71,3,71,
        1408,8,71,1,71,1,71,1,71,1,71,3,71,1414,8,71,1,71,3,71,1417,8,71,
        1,71,1,71,3,71,1421,8,71,1,71,1,71,1,72,1,72,1,72,3,72,1428,8,72,
        1,72,1,72,3,72,1432,8,72,1,72,1,72,1,72,1,72,3,72,1438,8,72,1,72,
        3,72,1441,8,72,1,72,1,72,3,72,1445,8,72,1,72,1,72,1,73,1,73,1,73,
        1,73,3,73,1453,8,73,1,73,1,73,3,73,1457,8,73,1,73,3,73,1460,8,73,
        1,73,3,73,1463,8,73,1,73,1,73,3,73,1467,8,73,1,73,1,73,1,74,1,74,
        1,74,1,74,3,74,1475,8,74,1,74,1,74,3,74,1479,8,74,1,74,1,74,3,74,
        1483,8,74,3,74,1485,8,74,1,74,3,74,1488,8,74,1,75,1,75,1,75,3,75,
        1493,8,75,1,76,1,76,1,76,1,76,3,76,1499,8,76,1,76,1,76,3,76,1503,
        8,76,1,76,1,76,3,76,1507,8,76,1,76,5,76,1510,8,76,10,76,12,76,1513,
        9,76,1,77,1,77,3,77,1517,8,77,1,77,1,77,3,77,1521,8,77,1,77,1,77,
        3,77,1525,8,77,1,77,1,77,1,77,3,77,1530,8,77,1,78,1,78,1,79,1,79,
        1,79,1,79,3,79,1538,8,79,3,79,1540,8,79,1,80,1,80,1,81,1,81,1,81,
        1,81,1,82,1,82,1,82,1,82,3,82,1552,8,82,1,82,1,82,3,82,1556,8,82,
        1,82,1,82,1,83,1,83,1,83,1,83,3,83,1564,8,83,1,83,1,83,3,83,1568,
        8,83,1,83,1,83,1,84,1,84,1,84,1,84,3,84,1576,8,84,1,84,1,84,3,84,
        1580,8,84,1,84,1,84,3,84,1584,8,84,1,84,1,84,3,84,1588,8,84,1,84,
        1,84,3,84,1592,8,84,1,84,1,84,3,84,1596,8,84,1,84,1,84,1,85,1,85,
        1,85,1,85,3,85,1604,8,85,1,85,1,85,3,85,1608,8,85,1,85,1,85,1,86,
        1,86,1,86,1,86,1,86,1,86,1,86,5,86,1619,8,86,10,86,12,86,1622,9,
        86,1,86,1,86,1,87,1,87,3,87,1628,8,87,1,87,1,87,3,87,1632,8,87,1,
        87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,3,87,1643,8,87,1,88,1,
        88,1,88,1,88,1,88,3,88,1650,8,88,1,89,1,89,1,89,3,89,1655,8,89,1,
        89,1,89,3,89,1659,8,89,1,89,5,89,1662,8,89,10,89,12,89,1665,9,89,
        3,89,1667,8,89,1,90,1,90,1,90,1,90,3,90,1673,8,90,1,90,1,90,3,90,
        1677,8,90,1,90,3,90,1680,8,90,1,91,1,91,1,91,1,91,3,91,1686,8,91,
        1,91,1,91,3,91,1690,8,91,1,91,1,91,1,92,1,92,1,92,1,92,3,92,1698,
        8,92,1,92,1,92,3,92,1702,8,92,1,92,1,92,1,93,1,93,1,94,1,94,1,94,
        3,94,1711,8,94,1,94,1,94,3,94,1715,8,94,1,94,1,94,3,94,1719,8,94,
        1,94,1,94,3,94,1723,8,94,1,94,3,94,1726,8,94,1,94,1,94,3,94,1730,
        8,94,1,94,1,94,1,95,1,95,3,95,1736,8,95,1,95,1,95,3,95,1740,8,95,
        1,95,1,95,1,96,1,96,1,96,3,96,1747,8,96,1,96,1,96,1,96,1,96,1,96,
        5,96,1754,8,96,10,96,12,96,1757,9,96,1,96,1,96,1,97,1,97,3,97,1763,
        8,97,1,97,1,97,3,97,1767,8,97,1,97,3,97,1770,8,97,1,97,3,97,1773,
        8,97,1,97,3,97,1776,8,97,1,97,1,97,3,97,1780,8,97,1,97,1,97,1,98,
        1,98,1,98,1,98,1,98,1,98,1,98,3,98,1791,8,98,1,99,1,99,1,99,1,99,
        1,100,1,100,1,100,1,100,3,100,1801,8,100,1,100,1,100,3,100,1805,
        8,100,1,100,1,100,1,100,1,100,1,100,3,100,1812,8,100,3,100,1814,
        8,100,1,101,1,101,1,101,1,101,1,101,3,101,1821,8,101,1,101,1,101,
        3,101,1825,8,101,1,101,1,101,3,101,1829,8,101,1,101,5,101,1832,8,
        101,10,101,12,101,1835,9,101,1,101,1,101,1,101,1,101,3,101,1841,
        8,101,1,101,1,101,1,101,1,101,1,101,3,101,1848,8,101,1,101,1,101,
        1,101,3,101,1853,8,101,1,101,1,101,3,101,1857,8,101,1,101,1,101,
        1,101,1,101,3,101,1863,8,101,1,101,1,101,1,101,3,101,1868,8,101,
        1,101,1,101,1,101,3,101,1873,8,101,1,101,3,101,1876,8,101,1,101,
        1,101,3,101,1880,8,101,1,101,1,101,3,101,1884,8,101,1,101,1,101,
        1,101,3,101,1889,8,101,1,101,1,101,3,101,1893,8,101,1,101,1,101,
        1,101,3,101,1898,8,101,1,101,1,101,3,101,1902,8,101,1,101,1,101,
        1,101,3,101,1907,8,101,1,101,1,101,3,101,1911,8,101,1,101,1,101,
        1,101,3,101,1916,8,101,1,101,1,101,3,101,1920,8,101,1,101,1,101,
        1,101,3,101,1925,8,101,1,101,1,101,3,101,1929,8,101,1,101,1,101,
        1,101,3,101,1934,8,101,1,101,1,101,3,101,1938,8,101,1,101,1,101,
        1,101,3,101,1943,8,101,1,101,1,101,3,101,1947,8,101,1,101,1,101,
        1,101,3,101,1952,8,101,1,101,1,101,3,101,1956,8,101,1,101,1,101,
        1,101,3,101,1961,8,101,1,101,1,101,3,101,1965,8,101,1,101,1,101,
        1,101,3,101,1970,8,101,1,101,1,101,3,101,1974,8,101,1,101,5,101,
        1977,8,101,10,101,12,101,1980,9,101,1,102,1,102,1,102,3,102,1985,
        8,102,1,102,1,102,1,102,3,102,1990,8,102,1,102,1,102,1,103,1,103,
        3,103,1996,8,103,1,103,1,103,3,103,2000,8,103,1,103,5,103,2003,8,
        103,10,103,12,103,2006,9,103,1,104,1,104,3,104,2010,8,104,1,104,
        1,104,3,104,2014,8,104,1,104,1,104,3,104,2018,8,104,3,104,2020,8,
        104,1,104,1,104,3,104,2024,8,104,3,104,2026,8,104,1,104,3,104,2029,
        8,104,1,104,1,104,3,104,2033,8,104,1,105,1,105,1,105,1,105,1,105,
        3,105,2040,8,105,1,105,1,105,1,106,1,106,1,106,1,106,3,106,2048,
        8,106,1,106,1,106,3,106,2052,8,106,1,106,1,106,1,107,1,107,1,107,
        1,107,1,107,1,107,3,107,2062,8,107,1,107,1,107,3,107,2066,8,107,
        1,107,1,107,1,108,1,108,1,108,1,108,3,108,2074,8,108,1,108,1,108,
        3,108,2078,8,108,1,108,3,108,2081,8,108,1,109,3,109,2084,8,109,1,
        109,1,109,1,110,1,110,3,110,2090,8,110,1,111,1,111,1,111,1,111,3,
        111,2096,8,111,1,111,3,111,2099,8,111,1,111,1,111,3,111,2103,8,111,
        1,111,1,111,3,111,2107,8,111,1,111,1,111,3,111,2111,8,111,1,111,
        3,111,2114,8,111,1,111,1,111,1,111,1,111,5,111,2120,8,111,10,111,
        12,111,2123,9,111,1,112,1,112,1,112,3,112,2128,8,112,1,112,1,112,
        1,112,3,112,2133,8,112,1,112,3,112,2136,8,112,1,112,1,112,3,112,
        2140,8,112,1,112,1,112,3,112,2144,8,112,1,112,1,112,3,112,2148,8,
        112,1,112,3,112,2151,8,112,1,112,1,112,1,112,1,112,5,112,2157,8,
        112,10,112,12,112,2160,9,112,1,113,1,113,3,113,2164,8,113,1,114,
        3,114,2167,8,114,1,114,1,114,1,114,3,114,2172,8,114,1,114,1,114,
        3,114,2176,8,114,1,114,3,114,2179,8,114,1,114,3,114,2182,8,114,1,
        114,1,114,1,114,1,114,5,114,2188,8,114,10,114,12,114,2191,9,114,
        1,115,1,115,1,115,3,115,2196,8,115,1,115,3,115,2199,8,115,1,115,
        1,115,1,115,1,115,5,115,2205,8,115,10,115,12,115,2208,9,115,1,116,
        1,116,1,116,1,116,3,116,2214,8,116,1,117,1,117,3,117,2218,8,117,
        1,117,3,117,2221,8,117,1,117,3,117,2224,8,117,1,117,1,117,1,117,
        1,117,5,117,2230,8,117,10,117,12,117,2233,9,117,1,118,1,118,3,118,
        2237,8,118,1,118,3,118,2240,8,118,1,118,3,118,2243,8,118,1,118,1,
        118,3,118,2247,8,118,1,118,1,118,3,118,2251,8,118,3,118,2253,8,118,
        1,118,1,118,3,118,2257,8,118,1,118,3,118,2260,8,118,1,118,1,118,
        1,118,1,118,5,118,2266,8,118,10,118,12,118,2269,9,118,1,119,1,119,
        3,119,2273,8,119,1,119,4,119,2276,8,119,11,119,12,119,2277,1,119,
        3,119,2281,8,119,1,119,3,119,2284,8,119,1,119,1,119,1,119,1,119,
        5,119,2290,8,119,10,119,12,119,2293,9,119,1,120,3,120,2296,8,120,
        1,120,1,120,3,120,2300,8,120,1,120,1,120,3,120,2304,8,120,1,121,
        1,121,1,122,3,122,2309,8,122,1,122,3,122,2312,8,122,1,122,1,122,
        3,122,2316,8,122,5,122,2318,8,122,10,122,12,122,2321,9,122,1,122,
        1,122,3,122,2325,8,122,1,122,1,122,3,122,2329,8,122,1,122,3,122,
        2332,8,122,5,122,2334,8,122,10,122,12,122,2337,9,122,1,123,3,123,
        2340,8,123,1,123,1,123,3,123,2344,8,123,1,123,3,123,2347,8,123,1,
        123,1,123,1,124,1,124,1,124,3,124,2354,8,124,1,125,1,125,3,125,2358,
        8,125,1,125,1,125,3,125,2362,8,125,1,125,1,125,3,125,2366,8,125,
        1,125,5,125,2369,8,125,10,125,12,125,2372,9,125,3,125,2374,8,125,
        1,125,3,125,2377,8,125,1,125,1,125,1,126,1,126,3,126,2383,8,126,
        1,126,1,126,3,126,2387,8,126,1,126,1,126,3,126,2391,8,126,1,126,
        1,126,3,126,2395,8,126,1,126,3,126,2398,8,126,1,126,1,126,3,126,
        2402,8,126,1,126,3,126,2405,8,126,1,126,3,126,2408,8,126,1,126,3,
        126,2411,8,126,1,126,3,126,2414,8,126,1,126,3,126,2417,8,126,1,127,
        1,127,3,127,2421,8,127,1,127,1,127,1,128,1,128,3,128,2427,8,128,
        1,128,1,128,3,128,2431,8,128,1,128,5,128,2434,8,128,10,128,12,128,
        2437,9,128,1,129,1,129,1,129,1,129,1,129,3,129,2444,8,129,1,129,
        1,129,1,130,1,130,4,130,2450,8,130,11,130,12,130,2451,1,131,1,131,
        3,131,2456,8,131,1,131,1,131,3,131,2460,8,131,1,131,1,131,3,131,
        2464,8,131,1,131,3,131,2467,8,131,1,132,1,132,1,132,1,132,1,132,
        1,132,1,132,1,132,1,132,1,132,3,132,2479,8,132,1,132,1,132,3,132,
        2483,8,132,1,132,3,132,2486,8,132,1,132,3,132,2489,8,132,1,133,1,
        133,1,133,5,133,2494,8,133,10,133,12,133,2497,9,133,1,133,1,133,
        1,133,4,133,2502,8,133,11,133,12,133,2503,3,133,2506,8,133,1,134,
        1,134,1,135,1,135,1,135,5,135,2513,8,135,10,135,12,135,2516,9,135,
        1,136,1,136,3,136,2520,8,136,1,136,1,136,3,136,2524,8,136,1,137,
        1,137,3,137,2528,8,137,1,137,1,137,3,137,2532,8,137,1,137,3,137,
        2535,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,3,140,2544,
        8,140,1,140,3,140,2547,8,140,1,140,1,140,3,140,2551,8,140,1,140,
        3,140,2554,8,140,1,141,1,141,1,142,1,142,1,143,1,143,1,144,1,144,
        1,145,1,145,1,146,3,146,2567,8,146,1,146,1,146,1,146,3,146,2572,
        8,146,1,146,3,146,2575,8,146,1,147,1,147,3,147,2579,8,147,1,147,
        1,147,3,147,2583,8,147,5,147,2585,8,147,10,147,12,147,2588,9,147,
        1,147,1,819,1,202,148,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
        32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,
        76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,
        114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,
        146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,
        178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,
        210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,
        242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,
        274,276,278,280,282,284,286,288,290,292,294,0,22,3,0,19,19,32,32,
        167,167,1,0,35,46,2,0,176,176,180,180,1,0,68,72,3,0,189,189,196,
        196,200,200,1,0,208,209,1,0,119,120,5,0,15,15,19,19,86,86,128,128,
        139,139,2,0,142,143,184,184,2,0,99,101,158,158,1,0,1,2,2,0,160,160,
        166,166,2,0,188,188,197,197,2,0,195,195,199,199,5,0,87,87,97,97,
        189,192,194,194,198,198,1,0,4,5,2,0,21,22,129,129,1,0,21,22,4,0,
        73,73,116,117,171,171,205,211,3,0,3,3,5,8,186,186,4,0,75,75,79,79,
        132,132,137,137,9,0,9,53,62,67,73,97,102,102,108,118,121,122,127,
        132,137,142,144,185,2997,0,296,1,0,0,0,2,300,1,0,0,0,4,356,1,0,0,
        0,6,362,1,0,0,0,8,376,1,0,0,0,10,397,1,0,0,0,12,401,1,0,0,0,14,428,
        1,0,0,0,16,441,1,0,0,0,18,445,1,0,0,0,20,447,1,0,0,0,22,472,1,0,
        0,0,24,474,1,0,0,0,26,498,1,0,0,0,28,577,1,0,0,0,30,579,1,0,0,0,
        32,592,1,0,0,0,34,594,1,0,0,0,36,598,1,0,0,0,38,602,1,0,0,0,40,623,
        1,0,0,0,42,641,1,0,0,0,44,658,1,0,0,0,46,671,1,0,0,0,48,711,1,0,
        0,0,50,727,1,0,0,0,52,775,1,0,0,0,54,777,1,0,0,0,56,782,1,0,0,0,
        58,796,1,0,0,0,60,809,1,0,0,0,62,822,1,0,0,0,64,829,1,0,0,0,66,839,
        1,0,0,0,68,841,1,0,0,0,70,853,1,0,0,0,72,874,1,0,0,0,74,914,1,0,
        0,0,76,946,1,0,0,0,78,968,1,0,0,0,80,972,1,0,0,0,82,1001,1,0,0,0,
        84,1003,1,0,0,0,86,1012,1,0,0,0,88,1014,1,0,0,0,90,1023,1,0,0,0,
        92,1028,1,0,0,0,94,1032,1,0,0,0,96,1047,1,0,0,0,98,1053,1,0,0,0,
        100,1065,1,0,0,0,102,1077,1,0,0,0,104,1090,1,0,0,0,106,1094,1,0,
        0,0,108,1113,1,0,0,0,110,1125,1,0,0,0,112,1139,1,0,0,0,114,1151,
        1,0,0,0,116,1167,1,0,0,0,118,1183,1,0,0,0,120,1193,1,0,0,0,122,1207,
        1,0,0,0,124,1211,1,0,0,0,126,1219,1,0,0,0,128,1229,1,0,0,0,130,1249,
        1,0,0,0,132,1269,1,0,0,0,134,1335,1,0,0,0,136,1354,1,0,0,0,138,1356,
        1,0,0,0,140,1372,1,0,0,0,142,1403,1,0,0,0,144,1427,1,0,0,0,146,1448,
        1,0,0,0,148,1470,1,0,0,0,150,1489,1,0,0,0,152,1494,1,0,0,0,154,1514,
        1,0,0,0,156,1531,1,0,0,0,158,1533,1,0,0,0,160,1541,1,0,0,0,162,1543,
        1,0,0,0,164,1547,1,0,0,0,166,1559,1,0,0,0,168,1571,1,0,0,0,170,1599,
        1,0,0,0,172,1611,1,0,0,0,174,1642,1,0,0,0,176,1644,1,0,0,0,178,1666,
        1,0,0,0,180,1668,1,0,0,0,182,1681,1,0,0,0,184,1693,1,0,0,0,186,1705,
        1,0,0,0,188,1710,1,0,0,0,190,1733,1,0,0,0,192,1746,1,0,0,0,194,1760,
        1,0,0,0,196,1783,1,0,0,0,198,1792,1,0,0,0,200,1796,1,0,0,0,202,1875,
        1,0,0,0,204,1984,1,0,0,0,206,1993,1,0,0,0,208,2007,1,0,0,0,210,2034,
        1,0,0,0,212,2043,1,0,0,0,214,2055,1,0,0,0,216,2069,1,0,0,0,218,2083,
        1,0,0,0,220,2089,1,0,0,0,222,2091,1,0,0,0,224,2124,1,0,0,0,226,2163,
        1,0,0,0,228,2166,1,0,0,0,230,2192,1,0,0,0,232,2213,1,0,0,0,234,2215,
        1,0,0,0,236,2236,1,0,0,0,238,2272,1,0,0,0,240,2295,1,0,0,0,242,2305,
        1,0,0,0,244,2319,1,0,0,0,246,2339,1,0,0,0,248,2350,1,0,0,0,250,2355,
        1,0,0,0,252,2382,1,0,0,0,254,2418,1,0,0,0,256,2424,1,0,0,0,258,2443,
        1,0,0,0,260,2449,1,0,0,0,262,2453,1,0,0,0,264,2488,1,0,0,0,266,2505,
        1,0,0,0,268,2507,1,0,0,0,270,2509,1,0,0,0,272,2517,1,0,0,0,274,2525,
        1,0,0,0,276,2536,1,0,0,0,278,2539,1,0,0,0,280,2543,1,0,0,0,282,2555,
        1,0,0,0,284,2557,1,0,0,0,286,2559,1,0,0,0,288,2561,1,0,0,0,290,2563,
        1,0,0,0,292,2566,1,0,0,0,294,2586,1,0,0,0,296,297,3,2,1,0,297,298,
        5,0,0,1,298,1,1,0,0,0,299,301,5,219,0,0,300,299,1,0,0,0,300,301,
        1,0,0,0,301,305,1,0,0,0,302,304,3,292,146,0,303,302,1,0,0,0,304,
        307,1,0,0,0,305,303,1,0,0,0,305,306,1,0,0,0,306,315,1,0,0,0,307,
        305,1,0,0,0,308,312,3,4,2,0,309,311,3,292,146,0,310,309,1,0,0,0,
        311,314,1,0,0,0,312,310,1,0,0,0,312,313,1,0,0,0,313,316,1,0,0,0,
        314,312,1,0,0,0,315,308,1,0,0,0,315,316,1,0,0,0,316,318,1,0,0,0,
        317,319,3,6,3,0,318,317,1,0,0,0,318,319,1,0,0,0,319,323,1,0,0,0,
        320,322,3,292,146,0,321,320,1,0,0,0,322,325,1,0,0,0,323,321,1,0,
        0,0,323,324,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,326,328,3,10,
        5,0,327,326,1,0,0,0,327,328,1,0,0,0,328,332,1,0,0,0,329,331,3,292,
        146,0,330,329,1,0,0,0,331,334,1,0,0,0,332,330,1,0,0,0,332,333,1,
        0,0,0,333,336,1,0,0,0,334,332,1,0,0,0,335,337,3,12,6,0,336,335,1,
        0,0,0,336,337,1,0,0,0,337,341,1,0,0,0,338,340,3,292,146,0,339,338,
        1,0,0,0,340,343,1,0,0,0,341,339,1,0,0,0,341,342,1,0,0,0,342,345,
        1,0,0,0,343,341,1,0,0,0,344,346,3,20,10,0,345,344,1,0,0,0,345,346,
        1,0,0,0,346,350,1,0,0,0,347,349,3,292,146,0,348,347,1,0,0,0,349,
        352,1,0,0,0,350,348,1,0,0,0,350,351,1,0,0,0,351,354,1,0,0,0,352,
        350,1,0,0,0,353,355,5,219,0,0,354,353,1,0,0,0,354,355,1,0,0,0,355,
        3,1,0,0,0,356,357,5,178,0,0,357,358,5,219,0,0,358,359,5,210,0,0,
        359,360,5,219,0,0,360,361,5,28,0,0,361,5,1,0,0,0,362,366,5,17,0,
        0,363,365,3,292,146,0,364,363,1,0,0,0,365,368,1,0,0,0,366,364,1,
        0,0,0,366,367,1,0,0,0,367,370,1,0,0,0,368,366,1,0,0,0,369,371,3,
        8,4,0,370,369,1,0,0,0,371,372,1,0,0,0,372,370,1,0,0,0,372,373,1,
        0,0,0,373,374,1,0,0,0,374,375,5,62,0,0,375,7,1,0,0,0,376,378,3,260,
        130,0,377,379,5,219,0,0,378,377,1,0,0,0,378,379,1,0,0,0,379,380,
        1,0,0,0,380,382,5,189,0,0,381,383,5,219,0,0,382,381,1,0,0,0,382,
        383,1,0,0,0,383,384,1,0,0,0,384,388,3,278,139,0,385,387,3,292,146,
        0,386,385,1,0,0,0,387,390,1,0,0,0,388,386,1,0,0,0,388,389,1,0,0,
        0,389,9,1,0,0,0,390,388,1,0,0,0,391,393,3,24,12,0,392,394,3,292,
        146,0,393,392,1,0,0,0,394,395,1,0,0,0,395,393,1,0,0,0,395,396,1,
        0,0,0,396,398,1,0,0,0,397,391,1,0,0,0,398,399,1,0,0,0,399,397,1,
        0,0,0,399,400,1,0,0,0,400,11,1,0,0,0,401,411,3,16,8,0,402,404,3,
        292,146,0,403,402,1,0,0,0,404,405,1,0,0,0,405,403,1,0,0,0,405,406,
        1,0,0,0,406,407,1,0,0,0,407,408,3,16,8,0,408,410,1,0,0,0,409,403,
        1,0,0,0,410,413,1,0,0,0,411,409,1,0,0,0,411,412,1,0,0,0,412,417,
        1,0,0,0,413,411,1,0,0,0,414,416,3,292,146,0,415,414,1,0,0,0,416,
        419,1,0,0,0,417,415,1,0,0,0,417,418,1,0,0,0,418,13,1,0,0,0,419,417,
        1,0,0,0,420,421,5,123,0,0,421,422,5,219,0,0,422,429,5,208,0,0,423,
        424,5,125,0,0,424,425,5,219,0,0,425,429,7,0,0,0,426,429,5,124,0,
        0,427,429,5,126,0,0,428,420,1,0,0,0,428,423,1,0,0,0,428,426,1,0,
        0,0,428,427,1,0,0,0,429,15,1,0,0,0,430,442,3,290,145,0,431,442,3,
        46,23,0,432,442,3,56,28,0,433,442,3,64,32,0,434,442,3,40,20,0,435,
        442,3,92,46,0,436,442,3,204,102,0,437,442,3,14,7,0,438,442,3,192,
        96,0,439,442,3,48,24,0,440,442,3,18,9,0,441,430,1,0,0,0,441,431,
        1,0,0,0,441,432,1,0,0,0,441,433,1,0,0,0,441,434,1,0,0,0,441,435,
        1,0,0,0,441,436,1,0,0,0,441,437,1,0,0,0,441,438,1,0,0,0,441,439,
        1,0,0,0,441,440,1,0,0,0,442,17,1,0,0,0,443,446,3,110,55,0,444,446,
        3,112,56,0,445,443,1,0,0,0,445,444,1,0,0,0,446,19,1,0,0,0,447,457,
        3,22,11,0,448,450,3,292,146,0,449,448,1,0,0,0,450,451,1,0,0,0,451,
        449,1,0,0,0,451,452,1,0,0,0,452,453,1,0,0,0,453,454,3,22,11,0,454,
        456,1,0,0,0,455,449,1,0,0,0,456,459,1,0,0,0,457,455,1,0,0,0,457,
        458,1,0,0,0,458,463,1,0,0,0,459,457,1,0,0,0,460,462,3,292,146,0,
        461,460,1,0,0,0,462,465,1,0,0,0,463,461,1,0,0,0,463,464,1,0,0,0,
        464,21,1,0,0,0,465,463,1,0,0,0,466,473,3,74,37,0,467,473,3,140,70,
        0,468,473,3,142,71,0,469,473,3,144,72,0,470,473,3,188,94,0,471,473,
        3,18,9,0,472,466,1,0,0,0,472,467,1,0,0,0,472,468,1,0,0,0,472,469,
        1,0,0,0,472,470,1,0,0,0,472,471,1,0,0,0,473,23,1,0,0,0,474,475,5,
        13,0,0,475,476,5,219,0,0,476,478,3,232,116,0,477,479,5,219,0,0,478,
        477,1,0,0,0,478,479,1,0,0,0,479,480,1,0,0,0,480,482,5,189,0,0,481,
        483,5,219,0,0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,1,0,0,0,484,
        495,3,278,139,0,485,487,5,219,0,0,486,485,1,0,0,0,486,487,1,0,0,
        0,487,488,1,0,0,0,488,490,5,1,0,0,489,491,5,219,0,0,490,489,1,0,
        0,0,490,491,1,0,0,0,491,492,1,0,0,0,492,494,3,278,139,0,493,486,
        1,0,0,0,494,497,1,0,0,0,495,493,1,0,0,0,495,496,1,0,0,0,496,25,1,
        0,0,0,497,495,1,0,0,0,498,504,3,28,14,0,499,500,3,294,147,0,500,
        501,3,28,14,0,501,503,1,0,0,0,502,499,1,0,0,0,503,506,1,0,0,0,504,
        502,1,0,0,0,504,505,1,0,0,0,505,507,1,0,0,0,506,504,1,0,0,0,507,
        508,3,294,147,0,508,27,1,0,0,0,509,578,3,276,138,0,510,578,3,30,
        15,0,511,578,3,24,12,0,512,578,3,32,16,0,513,578,3,34,17,0,514,578,
        3,36,18,0,515,578,3,38,19,0,516,578,3,40,20,0,517,578,3,44,22,0,
        518,578,3,50,25,0,519,578,3,52,26,0,520,578,3,54,27,0,521,578,3,
        60,30,0,522,578,3,62,31,0,523,578,3,66,33,0,524,578,3,220,110,0,
        525,578,3,68,34,0,526,578,3,70,35,0,527,578,3,72,36,0,528,578,3,
        76,38,0,529,578,3,78,39,0,530,578,3,80,40,0,531,578,3,82,41,0,532,
        578,3,92,46,0,533,578,3,94,47,0,534,578,3,96,48,0,535,578,3,98,49,
        0,536,578,3,100,50,0,537,578,3,102,51,0,538,578,3,104,52,0,539,578,
        3,106,53,0,540,578,3,108,54,0,541,578,3,18,9,0,542,578,3,120,60,
        0,543,578,3,122,61,0,544,578,3,124,62,0,545,578,3,126,63,0,546,578,
        3,128,64,0,547,578,3,130,65,0,548,578,3,132,66,0,549,578,3,138,69,
        0,550,578,3,146,73,0,551,578,3,148,74,0,552,578,3,150,75,0,553,578,
        3,152,76,0,554,578,3,156,78,0,555,578,3,158,79,0,556,578,3,160,80,
        0,557,578,3,162,81,0,558,578,3,164,82,0,559,578,3,166,83,0,560,578,
        3,168,84,0,561,578,3,170,85,0,562,578,3,172,86,0,563,578,3,180,90,
        0,564,578,3,182,91,0,565,578,3,184,92,0,566,578,3,186,93,0,567,578,
        3,190,95,0,568,578,3,198,99,0,569,578,3,200,100,0,570,578,3,204,
        102,0,571,578,3,210,105,0,572,578,3,212,106,0,573,578,3,214,107,
        0,574,578,3,216,108,0,575,578,3,226,113,0,576,578,3,232,116,0,577,
        509,1,0,0,0,577,510,1,0,0,0,577,511,1,0,0,0,577,512,1,0,0,0,577,
        513,1,0,0,0,577,514,1,0,0,0,577,515,1,0,0,0,577,516,1,0,0,0,577,
        517,1,0,0,0,577,518,1,0,0,0,577,519,1,0,0,0,577,520,1,0,0,0,577,
        521,1,0,0,0,577,522,1,0,0,0,577,523,1,0,0,0,577,524,1,0,0,0,577,
        525,1,0,0,0,577,526,1,0,0,0,577,527,1,0,0,0,577,528,1,0,0,0,577,
        529,1,0,0,0,577,530,1,0,0,0,577,531,1,0,0,0,577,532,1,0,0,0,577,
        533,1,0,0,0,577,534,1,0,0,0,577,535,1,0,0,0,577,536,1,0,0,0,577,
        537,1,0,0,0,577,538,1,0,0,0,577,539,1,0,0,0,577,540,1,0,0,0,577,
        541,1,0,0,0,577,542,1,0,0,0,577,543,1,0,0,0,577,544,1,0,0,0,577,
        545,1,0,0,0,577,546,1,0,0,0,577,547,1,0,0,0,577,548,1,0,0,0,577,
        549,1,0,0,0,577,550,1,0,0,0,577,551,1,0,0,0,577,552,1,0,0,0,577,
        553,1,0,0,0,577,554,1,0,0,0,577,555,1,0,0,0,577,556,1,0,0,0,577,
        557,1,0,0,0,577,558,1,0,0,0,577,559,1,0,0,0,577,560,1,0,0,0,577,
        561,1,0,0,0,577,562,1,0,0,0,577,563,1,0,0,0,577,564,1,0,0,0,577,
        565,1,0,0,0,577,566,1,0,0,0,577,567,1,0,0,0,577,568,1,0,0,0,577,
        569,1,0,0,0,577,570,1,0,0,0,577,571,1,0,0,0,577,572,1,0,0,0,577,
        573,1,0,0,0,577,574,1,0,0,0,577,575,1,0,0,0,577,576,1,0,0,0,578,
        29,1,0,0,0,579,580,5,14,0,0,580,581,5,219,0,0,581,590,3,202,101,
        0,582,584,5,219,0,0,583,582,1,0,0,0,583,584,1,0,0,0,584,585,1,0,
        0,0,585,587,5,1,0,0,586,588,5,219,0,0,587,586,1,0,0,0,587,588,1,
        0,0,0,588,589,1,0,0,0,589,591,3,202,101,0,590,583,1,0,0,0,590,591,
        1,0,0,0,591,31,1,0,0,0,592,593,5,18,0,0,593,33,1,0,0,0,594,595,5,
        26,0,0,595,596,5,219,0,0,596,597,3,202,101,0,597,35,1,0,0,0,598,
        599,5,27,0,0,599,600,5,219,0,0,600,601,3,202,101,0,601,37,1,0,0,
        0,602,618,5,29,0,0,603,604,5,219,0,0,604,615,3,218,109,0,605,607,
        5,219,0,0,606,605,1,0,0,0,606,607,1,0,0,0,607,608,1,0,0,0,608,610,
        5,1,0,0,609,611,5,219,0,0,610,609,1,0,0,0,610,611,1,0,0,0,611,612,
        1,0,0,0,612,614,3,218,109,0,613,606,1,0,0,0,614,617,1,0,0,0,615,
        613,1,0,0,0,615,616,1,0,0,0,616,619,1,0,0,0,617,615,1,0,0,0,618,
        603,1,0,0,0,618,619,1,0,0,0,619,39,1,0,0,0,620,621,3,284,142,0,621,
        622,5,219,0,0,622,624,1,0,0,0,623,620,1,0,0,0,623,624,1,0,0,0,624,
        625,1,0,0,0,625,626,5,31,0,0,626,627,5,219,0,0,627,638,3,42,21,0,
        628,630,5,219,0,0,629,628,1,0,0,0,629,630,1,0,0,0,630,631,1,0,0,
        0,631,633,5,1,0,0,632,634,5,219,0,0,633,632,1,0,0,0,633,634,1,0,
        0,0,634,635,1,0,0,0,635,637,3,42,21,0,636,629,1,0,0,0,637,640,1,
        0,0,0,638,636,1,0,0,0,638,639,1,0,0,0,639,41,1,0,0,0,640,638,1,0,
        0,0,641,643,3,260,130,0,642,644,3,282,141,0,643,642,1,0,0,0,643,
        644,1,0,0,0,644,647,1,0,0,0,645,646,5,219,0,0,646,648,3,262,131,
        0,647,645,1,0,0,0,647,648,1,0,0,0,648,650,1,0,0,0,649,651,5,219,
        0,0,650,649,1,0,0,0,650,651,1,0,0,0,651,652,1,0,0,0,652,654,5,189,
        0,0,653,655,5,219,0,0,654,653,1,0,0,0,654,655,1,0,0,0,655,656,1,
        0,0,0,656,657,3,202,101,0,657,43,1,0,0,0,658,660,5,33,0,0,659,661,
        5,219,0,0,660,659,1,0,0,0,660,661,1,0,0,0,661,662,1,0,0,0,662,664,
        5,189,0,0,663,665,5,219,0,0,664,663,1,0,0,0,664,665,1,0,0,0,665,
        666,1,0,0,0,666,667,3,202,101,0,667,45,1,0,0,0,668,669,3,284,142,
        0,669,670,5,219,0,0,670,672,1,0,0,0,671,668,1,0,0,0,671,672,1,0,
        0,0,672,673,1,0,0,0,673,674,5,34,0,0,674,677,5,219,0,0,675,676,5,
        136,0,0,676,678,5,219,0,0,677,675,1,0,0,0,677,678,1,0,0,0,678,684,
        1,0,0,0,679,681,5,77,0,0,680,682,3,282,141,0,681,680,1,0,0,0,681,
        682,1,0,0,0,682,685,1,0,0,0,683,685,5,165,0,0,684,679,1,0,0,0,684,
        683,1,0,0,0,685,686,1,0,0,0,686,687,5,219,0,0,687,689,3,260,130,
        0,688,690,3,282,141,0,689,688,1,0,0,0,689,690,1,0,0,0,690,691,1,
        0,0,0,691,692,5,219,0,0,692,693,5,96,0,0,693,694,5,219,0,0,694,699,
        5,205,0,0,695,696,5,219,0,0,696,697,5,11,0,0,697,698,5,219,0,0,698,
        700,5,205,0,0,699,695,1,0,0,0,699,700,1,0,0,0,700,705,1,0,0,0,701,
        703,5,219,0,0,702,701,1,0,0,0,702,703,1,0,0,0,703,704,1,0,0,0,704,
        706,3,250,125,0,705,702,1,0,0,0,705,706,1,0,0,0,706,709,1,0,0,0,
        707,708,5,219,0,0,708,710,3,262,131,0,709,707,1,0,0,0,709,710,1,
        0,0,0,710,47,1,0,0,0,711,712,7,1,0,0,712,713,5,219,0,0,713,724,3,
        274,137,0,714,716,5,219,0,0,715,714,1,0,0,0,715,716,1,0,0,0,716,
        717,1,0,0,0,717,719,5,1,0,0,718,720,5,219,0,0,719,718,1,0,0,0,719,
        720,1,0,0,0,720,721,1,0,0,0,721,723,3,274,137,0,722,715,1,0,0,0,
        723,726,1,0,0,0,724,722,1,0,0,0,724,725,1,0,0,0,725,49,1,0,0,0,726,
        724,1,0,0,0,727,728,5,47,0,0,728,729,5,219,0,0,729,731,3,202,101,
        0,730,732,5,219,0,0,731,730,1,0,0,0,731,732,1,0,0,0,732,733,1,0,
        0,0,733,735,5,1,0,0,734,736,5,219,0,0,735,734,1,0,0,0,735,736,1,
        0,0,0,736,737,1,0,0,0,737,746,3,202,101,0,738,740,5,219,0,0,739,
        738,1,0,0,0,739,740,1,0,0,0,740,741,1,0,0,0,741,743,5,1,0,0,742,
        744,5,219,0,0,743,742,1,0,0,0,743,744,1,0,0,0,744,745,1,0,0,0,745,
        747,3,202,101,0,746,739,1,0,0,0,746,747,1,0,0,0,747,51,1,0,0,0,748,
        749,5,49,0,0,749,751,3,294,147,0,750,752,3,26,13,0,751,750,1,0,0,
        0,751,752,1,0,0,0,752,753,1,0,0,0,753,754,5,93,0,0,754,776,1,0,0,
        0,755,756,5,49,0,0,756,757,5,219,0,0,757,758,7,2,0,0,758,759,5,219,
        0,0,759,760,3,202,101,0,760,762,3,294,147,0,761,763,3,26,13,0,762,
        761,1,0,0,0,762,763,1,0,0,0,763,764,1,0,0,0,764,765,5,93,0,0,765,
        776,1,0,0,0,766,767,5,49,0,0,767,768,3,294,147,0,768,769,3,26,13,
        0,769,770,5,93,0,0,770,771,5,219,0,0,771,772,7,2,0,0,772,773,5,219,
        0,0,773,774,3,202,101,0,774,776,1,0,0,0,775,748,1,0,0,0,775,755,
        1,0,0,0,775,766,1,0,0,0,776,53,1,0,0,0,777,778,5,62,0,0,778,55,1,
        0,0,0,779,780,3,284,142,0,780,781,5,219,0,0,781,783,1,0,0,0,782,
        779,1,0,0,0,782,783,1,0,0,0,783,784,1,0,0,0,784,785,5,63,0,0,785,
        786,5,219,0,0,786,787,3,260,130,0,787,791,3,294,147,0,788,790,3,
        58,29,0,789,788,1,0,0,0,790,793,1,0,0,0,791,789,1,0,0,0,791,792,
        1,0,0,0,792,794,1,0,0,0,793,791,1,0,0,0,794,795,5,54,0,0,795,57,
        1,0,0,0,796,805,3,260,130,0,797,799,5,219,0,0,798,797,1,0,0,0,798,
        799,1,0,0,0,799,800,1,0,0,0,800,802,5,189,0,0,801,803,5,219,0,0,
        802,801,1,0,0,0,802,803,1,0,0,0,803,804,1,0,0,0,804,806,3,202,101,
        0,805,798,1,0,0,0,805,806,1,0,0,0,806,807,1,0,0,0,807,808,3,294,
        147,0,808,59,1,0,0,0,809,810,5,65,0,0,810,811,5,219,0,0,811,819,
        3,202,101,0,812,814,5,1,0,0,813,815,5,219,0,0,814,813,1,0,0,0,814,
        815,1,0,0,0,815,816,1,0,0,0,816,818,3,202,101,0,817,812,1,0,0,0,
        818,821,1,0,0,0,819,820,1,0,0,0,819,817,1,0,0,0,820,61,1,0,0,0,821,
        819,1,0,0,0,822,823,5,66,0,0,823,824,5,219,0,0,824,825,3,202,101,
        0,825,63,1,0,0,0,826,827,3,284,142,0,827,828,5,219,0,0,828,830,1,
        0,0,0,829,826,1,0,0,0,829,830,1,0,0,0,830,831,1,0,0,0,831,832,5,
        67,0,0,832,833,5,219,0,0,833,835,3,260,130,0,834,836,5,219,0,0,835,
        834,1,0,0,0,835,836,1,0,0,0,836,837,1,0,0,0,837,838,3,250,125,0,
        838,65,1,0,0,0,839,840,7,3,0,0,840,67,1,0,0,0,841,842,5,74,0,0,842,
        843,5,219,0,0,843,845,3,202,101,0,844,846,5,219,0,0,845,844,1,0,
        0,0,845,846,1,0,0,0,846,847,1,0,0,0,847,849,5,1,0,0,848,850,5,219,
        0,0,849,848,1,0,0,0,849,850,1,0,0,0,850,851,1,0,0,0,851,852,3,202,
        101,0,852,69,1,0,0,0,853,854,5,76,0,0,854,855,5,219,0,0,855,856,
        5,51,0,0,856,857,5,219,0,0,857,859,3,260,130,0,858,860,3,282,141,
        0,859,858,1,0,0,0,859,860,1,0,0,0,860,861,1,0,0,0,861,862,5,219,
        0,0,862,863,5,85,0,0,863,864,5,219,0,0,864,865,3,202,101,0,865,867,
        3,294,147,0,866,868,3,26,13,0,867,866,1,0,0,0,867,868,1,0,0,0,868,
        869,1,0,0,0,869,872,5,113,0,0,870,871,5,219,0,0,871,873,3,260,130,
        0,872,870,1,0,0,0,872,873,1,0,0,0,873,71,1,0,0,0,874,875,5,76,0,
        0,875,876,5,219,0,0,876,878,3,260,130,0,877,879,3,282,141,0,878,
        877,1,0,0,0,878,879,1,0,0,0,879,882,1,0,0,0,880,881,5,219,0,0,881,
        883,3,262,131,0,882,880,1,0,0,0,882,883,1,0,0,0,883,885,1,0,0,0,
        884,886,5,219,0,0,885,884,1,0,0,0,885,886,1,0,0,0,886,887,1,0,0,
        0,887,889,5,189,0,0,888,890,5,219,0,0,889,888,1,0,0,0,889,890,1,
        0,0,0,890,891,1,0,0,0,891,892,3,202,101,0,892,893,5,219,0,0,893,
        894,5,170,0,0,894,895,5,219,0,0,895,900,3,202,101,0,896,897,5,219,
        0,0,897,898,5,162,0,0,898,899,5,219,0,0,899,901,3,202,101,0,900,
        896,1,0,0,0,900,901,1,0,0,0,901,902,1,0,0,0,902,904,3,294,147,0,
        903,905,3,26,13,0,904,903,1,0,0,0,904,905,1,0,0,0,905,906,1,0,0,
        0,906,909,5,113,0,0,907,908,5,219,0,0,908,910,3,260,130,0,909,907,
        1,0,0,0,909,910,1,0,0,0,910,73,1,0,0,0,911,912,3,284,142,0,912,913,
        5,219,0,0,913,915,1,0,0,0,914,911,1,0,0,0,914,915,1,0,0,0,915,918,
        1,0,0,0,916,917,5,161,0,0,917,919,5,219,0,0,918,916,1,0,0,0,918,
        919,1,0,0,0,919,920,1,0,0,0,920,922,5,77,0,0,921,923,5,219,0,0,922,
        921,1,0,0,0,922,923,1,0,0,0,923,924,1,0,0,0,924,926,3,260,130,0,
        925,927,3,282,141,0,926,925,1,0,0,0,926,927,1,0,0,0,927,932,1,0,
        0,0,928,930,5,219,0,0,929,928,1,0,0,0,929,930,1,0,0,0,930,931,1,
        0,0,0,931,933,3,250,125,0,932,929,1,0,0,0,932,933,1,0,0,0,933,938,
        1,0,0,0,934,936,5,219,0,0,935,934,1,0,0,0,935,936,1,0,0,0,936,937,
        1,0,0,0,937,939,3,262,131,0,938,935,1,0,0,0,938,939,1,0,0,0,939,
        940,1,0,0,0,940,942,3,294,147,0,941,943,3,26,13,0,942,941,1,0,0,
        0,942,943,1,0,0,0,943,944,1,0,0,0,944,945,5,55,0,0,945,75,1,0,0,
        0,946,947,5,78,0,0,947,948,5,219,0,0,948,950,3,218,109,0,949,951,
        5,219,0,0,950,949,1,0,0,0,950,951,1,0,0,0,951,952,1,0,0,0,952,954,
        5,1,0,0,953,955,5,219,0,0,954,953,1,0,0,0,954,955,1,0,0,0,955,957,
        1,0,0,0,956,958,3,202,101,0,957,956,1,0,0,0,957,958,1,0,0,0,958,
        960,1,0,0,0,959,961,5,219,0,0,960,959,1,0,0,0,960,961,1,0,0,0,961,
        962,1,0,0,0,962,964,5,1,0,0,963,965,5,219,0,0,964,963,1,0,0,0,964,
        965,1,0,0,0,965,966,1,0,0,0,966,967,3,202,101,0,967,77,1,0,0,0,968,
        969,5,80,0,0,969,970,5,219,0,0,970,971,3,202,101,0,971,79,1,0,0,
        0,972,973,5,81,0,0,973,974,5,219,0,0,974,975,3,202,101,0,975,81,
        1,0,0,0,976,977,5,82,0,0,977,978,5,219,0,0,978,979,3,86,43,0,979,
        980,5,219,0,0,980,981,5,168,0,0,981,982,5,219,0,0,982,987,3,28,14,
        0,983,984,5,219,0,0,984,985,5,52,0,0,985,986,5,219,0,0,986,988,3,
        28,14,0,987,983,1,0,0,0,987,988,1,0,0,0,988,1002,1,0,0,0,989,993,
        3,84,42,0,990,992,3,88,44,0,991,990,1,0,0,0,992,995,1,0,0,0,993,
        991,1,0,0,0,993,994,1,0,0,0,994,997,1,0,0,0,995,993,1,0,0,0,996,
        998,3,90,45,0,997,996,1,0,0,0,997,998,1,0,0,0,998,999,1,0,0,0,999,
        1000,5,56,0,0,1000,1002,1,0,0,0,1001,976,1,0,0,0,1001,989,1,0,0,
        0,1002,83,1,0,0,0,1003,1004,5,82,0,0,1004,1005,5,219,0,0,1005,1006,
        3,86,43,0,1006,1007,5,219,0,0,1007,1008,5,168,0,0,1008,1010,3,294,
        147,0,1009,1011,3,26,13,0,1010,1009,1,0,0,0,1010,1011,1,0,0,0,1011,
        85,1,0,0,0,1012,1013,3,202,101,0,1013,87,1,0,0,0,1014,1015,5,53,
        0,0,1015,1016,5,219,0,0,1016,1017,3,86,43,0,1017,1018,5,219,0,0,
        1018,1019,5,168,0,0,1019,1021,3,294,147,0,1020,1022,3,26,13,0,1021,
        1020,1,0,0,0,1021,1022,1,0,0,0,1022,89,1,0,0,0,1023,1024,5,52,0,
        0,1024,1026,3,294,147,0,1025,1027,3,26,13,0,1026,1025,1,0,0,0,1026,
        1027,1,0,0,0,1027,91,1,0,0,0,1028,1029,5,84,0,0,1029,1030,5,219,
        0,0,1030,1031,3,260,130,0,1031,93,1,0,0,0,1032,1033,5,86,0,0,1033,
        1034,5,219,0,0,1034,1043,3,218,109,0,1035,1037,5,219,0,0,1036,1035,
        1,0,0,0,1036,1037,1,0,0,0,1037,1038,1,0,0,0,1038,1040,5,1,0,0,1039,
        1041,5,219,0,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041,1042,1,0,
        0,0,1042,1044,3,202,101,0,1043,1036,1,0,0,0,1044,1045,1,0,0,0,1045,
        1043,1,0,0,0,1045,1046,1,0,0,0,1046,95,1,0,0,0,1047,1048,5,89,0,
        0,1048,1049,5,219,0,0,1049,1050,3,202,101,0,1050,97,1,0,0,0,1051,
        1052,5,95,0,0,1052,1054,5,219,0,0,1053,1051,1,0,0,0,1053,1054,1,
        0,0,0,1054,1055,1,0,0,0,1055,1057,3,232,116,0,1056,1058,5,219,0,
        0,1057,1056,1,0,0,0,1057,1058,1,0,0,0,1058,1059,1,0,0,0,1059,1061,
        7,4,0,0,1060,1062,5,219,0,0,1061,1060,1,0,0,0,1061,1062,1,0,0,0,
        1062,1063,1,0,0,0,1063,1064,3,202,101,0,1064,99,1,0,0,0,1065,1066,
        5,98,0,0,1066,1067,5,219,0,0,1067,1069,3,218,109,0,1068,1070,5,219,
        0,0,1069,1068,1,0,0,0,1069,1070,1,0,0,0,1070,1071,1,0,0,0,1071,1073,
        5,1,0,0,1072,1074,5,219,0,0,1073,1072,1,0,0,0,1073,1074,1,0,0,0,
        1074,1075,1,0,0,0,1075,1076,3,202,101,0,1076,101,1,0,0,0,1077,1079,
        7,5,0,0,1078,1080,5,213,0,0,1079,1078,1,0,0,0,1079,1080,1,0,0,0,
        1080,1082,1,0,0,0,1081,1083,5,217,0,0,1082,1081,1,0,0,0,1082,1083,
        1,0,0,0,1083,1085,1,0,0,0,1084,1086,5,213,0,0,1085,1084,1,0,0,0,
        1085,1086,1,0,0,0,1086,1088,1,0,0,0,1087,1089,5,219,0,0,1088,1087,
        1,0,0,0,1088,1089,1,0,0,0,1089,103,1,0,0,0,1090,1091,5,90,0,0,1091,
        1092,5,219,0,0,1092,1093,3,202,101,0,1093,105,1,0,0,0,1094,1095,
        5,91,0,0,1095,1096,5,219,0,0,1096,1111,3,202,101,0,1097,1099,5,219,
        0,0,1098,1097,1,0,0,0,1098,1099,1,0,0,0,1099,1100,1,0,0,0,1100,1102,
        5,1,0,0,1101,1103,5,219,0,0,1102,1101,1,0,0,0,1102,1103,1,0,0,0,
        1103,1104,1,0,0,0,1104,1109,3,202,101,0,1105,1106,5,219,0,0,1106,
        1107,5,170,0,0,1107,1108,5,219,0,0,1108,1110,3,202,101,0,1109,1105,
        1,0,0,0,1109,1110,1,0,0,0,1110,1112,1,0,0,0,1111,1098,1,0,0,0,1111,
        1112,1,0,0,0,1112,107,1,0,0,0,1113,1114,5,102,0,0,1114,1115,5,219,
        0,0,1115,1117,3,232,116,0,1116,1118,5,219,0,0,1117,1116,1,0,0,0,
        1117,1118,1,0,0,0,1118,1119,1,0,0,0,1119,1121,5,189,0,0,1120,1122,
        5,219,0,0,1121,1120,1,0,0,0,1121,1122,1,0,0,0,1122,1123,1,0,0,0,
        1123,1124,3,202,101,0,1124,109,1,0,0,0,1125,1127,5,103,0,0,1126,
        1128,5,219,0,0,1127,1126,1,0,0,0,1127,1128,1,0,0,0,1128,1129,1,0,
        0,0,1129,1131,3,260,130,0,1130,1132,5,219,0,0,1131,1130,1,0,0,0,
        1131,1132,1,0,0,0,1132,1133,1,0,0,0,1133,1135,5,189,0,0,1134,1136,
        5,219,0,0,1135,1134,1,0,0,0,1135,1136,1,0,0,0,1136,1137,1,0,0,0,
        1137,1138,3,202,101,0,1138,111,1,0,0,0,1139,1143,3,114,57,0,1140,
        1142,3,116,58,0,1141,1140,1,0,0,0,1142,1145,1,0,0,0,1143,1141,1,
        0,0,0,1143,1144,1,0,0,0,1144,1147,1,0,0,0,1145,1143,1,0,0,0,1146,
        1148,3,118,59,0,1147,1146,1,0,0,0,1147,1148,1,0,0,0,1148,1149,1,
        0,0,0,1149,1150,5,107,0,0,1150,113,1,0,0,0,1151,1153,5,104,0,0,1152,
        1154,5,219,0,0,1153,1152,1,0,0,0,1153,1154,1,0,0,0,1154,1155,1,0,
        0,0,1155,1156,3,86,43,0,1156,1157,5,219,0,0,1157,1158,5,168,0,0,
        1158,1164,3,294,147,0,1159,1163,3,12,6,0,1160,1163,3,20,10,0,1161,
        1163,3,26,13,0,1162,1159,1,0,0,0,1162,1160,1,0,0,0,1162,1161,1,0,
        0,0,1163,1166,1,0,0,0,1164,1162,1,0,0,0,1164,1165,1,0,0,0,1165,115,
        1,0,0,0,1166,1164,1,0,0,0,1167,1169,5,105,0,0,1168,1170,5,219,0,
        0,1169,1168,1,0,0,0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,1171,1172,
        3,86,43,0,1172,1173,5,219,0,0,1173,1174,5,168,0,0,1174,1180,3,294,
        147,0,1175,1179,3,12,6,0,1176,1179,3,20,10,0,1177,1179,3,26,13,0,
        1178,1175,1,0,0,0,1178,1176,1,0,0,0,1178,1177,1,0,0,0,1179,1182,
        1,0,0,0,1180,1178,1,0,0,0,1180,1181,1,0,0,0,1181,117,1,0,0,0,1182,
        1180,1,0,0,0,1183,1184,5,106,0,0,1184,1190,3,294,147,0,1185,1189,
        3,12,6,0,1186,1189,3,20,10,0,1187,1189,3,26,13,0,1188,1185,1,0,0,
        0,1188,1186,1,0,0,0,1188,1187,1,0,0,0,1189,1192,1,0,0,0,1190,1188,
        1,0,0,0,1190,1191,1,0,0,0,1191,119,1,0,0,0,1192,1190,1,0,0,0,1193,
        1195,5,109,0,0,1194,1196,5,219,0,0,1195,1194,1,0,0,0,1195,1196,1,
        0,0,0,1196,1197,1,0,0,0,1197,1199,5,193,0,0,1198,1200,5,219,0,0,
        1199,1198,1,0,0,0,1199,1200,1,0,0,0,1200,1201,1,0,0,0,1201,1203,
        3,244,122,0,1202,1204,5,219,0,0,1203,1202,1,0,0,0,1203,1204,1,0,
        0,0,1204,1205,1,0,0,0,1205,1206,5,202,0,0,1206,121,1,0,0,0,1207,
        1208,5,110,0,0,1208,1209,5,219,0,0,1209,1210,3,202,101,0,1210,123,
        1,0,0,0,1211,1212,5,112,0,0,1212,1213,5,219,0,0,1213,1214,3,202,
        101,0,1214,1215,5,219,0,0,1215,1216,5,16,0,0,1216,1217,5,219,0,0,
        1217,1218,3,202,101,0,1218,125,1,0,0,0,1219,1220,7,6,0,0,1220,1227,
        5,219,0,0,1221,1222,5,81,0,0,1222,1223,5,219,0,0,1223,1228,3,202,
        101,0,1224,1225,5,147,0,0,1225,1226,5,219,0,0,1226,1228,5,113,0,
        0,1227,1221,1,0,0,0,1227,1224,1,0,0,0,1228,127,1,0,0,0,1229,1230,
        5,118,0,0,1230,1231,5,219,0,0,1231,1232,3,202,101,0,1232,1233,5,
        219,0,0,1233,1234,5,81,0,0,1234,1235,5,219,0,0,1235,1246,3,202,101,
        0,1236,1238,5,219,0,0,1237,1236,1,0,0,0,1237,1238,1,0,0,0,1238,1239,
        1,0,0,0,1239,1241,5,1,0,0,1240,1242,5,219,0,0,1241,1240,1,0,0,0,
        1241,1242,1,0,0,0,1242,1243,1,0,0,0,1243,1245,3,202,101,0,1244,1237,
        1,0,0,0,1245,1248,1,0,0,0,1246,1244,1,0,0,0,1246,1247,1,0,0,0,1247,
        129,1,0,0,0,1248,1246,1,0,0,0,1249,1250,5,118,0,0,1250,1251,5,219,
        0,0,1251,1252,3,202,101,0,1252,1253,5,219,0,0,1253,1254,5,80,0,0,
        1254,1255,5,219,0,0,1255,1266,3,202,101,0,1256,1258,5,219,0,0,1257,
        1256,1,0,0,0,1257,1258,1,0,0,0,1258,1259,1,0,0,0,1259,1261,5,1,0,
        0,1260,1262,5,219,0,0,1261,1260,1,0,0,0,1261,1262,1,0,0,0,1262,1263,
        1,0,0,0,1263,1265,3,202,101,0,1264,1257,1,0,0,0,1265,1268,1,0,0,
        0,1266,1264,1,0,0,0,1266,1267,1,0,0,0,1267,131,1,0,0,0,1268,1266,
        1,0,0,0,1269,1270,5,121,0,0,1270,1271,5,219,0,0,1271,1272,3,202,
        101,0,1272,1273,5,219,0,0,1273,1274,5,76,0,0,1274,1275,5,219,0,0,
        1275,1280,7,7,0,0,1276,1277,5,219,0,0,1277,1278,5,9,0,0,1278,1279,
        5,219,0,0,1279,1281,7,8,0,0,1280,1276,1,0,0,0,1280,1281,1,0,0,0,
        1281,1284,1,0,0,0,1282,1283,5,219,0,0,1283,1285,7,9,0,0,1284,1282,
        1,0,0,0,1284,1285,1,0,0,0,1285,1286,1,0,0,0,1286,1287,5,219,0,0,
        1287,1288,5,16,0,0,1288,1289,5,219,0,0,1289,1300,3,218,109,0,1290,
        1291,5,219,0,0,1291,1293,5,94,0,0,1292,1294,5,219,0,0,1293,1292,
        1,0,0,0,1293,1294,1,0,0,0,1294,1295,1,0,0,0,1295,1297,5,189,0,0,
        1296,1298,5,219,0,0,1297,1296,1,0,0,0,1297,1298,1,0,0,0,1298,1299,
        1,0,0,0,1299,1301,3,202,101,0,1300,1290,1,0,0,0,1300,1301,1,0,0,
        0,1301,133,1,0,0,0,1302,1315,3,136,68,0,1303,1305,5,219,0,0,1304,
        1303,1,0,0,0,1304,1305,1,0,0,0,1305,1306,1,0,0,0,1306,1308,7,10,
        0,0,1307,1309,5,219,0,0,1308,1307,1,0,0,0,1308,1309,1,0,0,0,1309,
        1311,1,0,0,0,1310,1312,3,136,68,0,1311,1310,1,0,0,0,1311,1312,1,
        0,0,0,1312,1314,1,0,0,0,1313,1304,1,0,0,0,1314,1317,1,0,0,0,1315,
        1313,1,0,0,0,1315,1316,1,0,0,0,1316,1336,1,0,0,0,1317,1315,1,0,0,
        0,1318,1320,3,136,68,0,1319,1318,1,0,0,0,1319,1320,1,0,0,0,1320,
        1331,1,0,0,0,1321,1323,5,219,0,0,1322,1321,1,0,0,0,1322,1323,1,0,
        0,0,1323,1324,1,0,0,0,1324,1326,7,10,0,0,1325,1327,5,219,0,0,1326,
        1325,1,0,0,0,1326,1327,1,0,0,0,1327,1329,1,0,0,0,1328,1330,3,136,
        68,0,1329,1328,1,0,0,0,1329,1330,1,0,0,0,1330,1332,1,0,0,0,1331,
        1322,1,0,0,0,1332,1333,1,0,0,0,1333,1331,1,0,0,0,1333,1334,1,0,0,
        0,1334,1336,1,0,0,0,1335,1302,1,0,0,0,1335,1319,1,0,0,0,1336,135,
        1,0,0,0,1337,1355,3,202,101,0,1338,1352,7,11,0,0,1339,1341,5,219,
        0,0,1340,1339,1,0,0,0,1340,1341,1,0,0,0,1341,1342,1,0,0,0,1342,1344,
        5,193,0,0,1343,1345,5,219,0,0,1344,1343,1,0,0,0,1344,1345,1,0,0,
        0,1345,1346,1,0,0,0,1346,1348,3,244,122,0,1347,1349,5,219,0,0,1348,
        1347,1,0,0,0,1348,1349,1,0,0,0,1349,1350,1,0,0,0,1350,1351,5,202,
        0,0,1351,1353,1,0,0,0,1352,1340,1,0,0,0,1352,1353,1,0,0,0,1353,1355,
        1,0,0,0,1354,1337,1,0,0,0,1354,1338,1,0,0,0,1355,137,1,0,0,0,1356,
        1357,5,131,0,0,1357,1358,5,219,0,0,1358,1360,3,218,109,0,1359,1361,
        5,219,0,0,1360,1359,1,0,0,0,1360,1361,1,0,0,0,1361,1362,1,0,0,0,
        1362,1367,5,1,0,0,1363,1365,5,219,0,0,1364,1363,1,0,0,0,1364,1365,
        1,0,0,0,1365,1366,1,0,0,0,1366,1368,3,134,67,0,1367,1364,1,0,0,0,
        1367,1368,1,0,0,0,1368,139,1,0,0,0,1369,1370,3,284,142,0,1370,1371,
        5,219,0,0,1371,1373,1,0,0,0,1372,1369,1,0,0,0,1372,1373,1,0,0,0,
        1373,1376,1,0,0,0,1374,1375,5,161,0,0,1375,1377,5,219,0,0,1376,1374,
        1,0,0,0,1376,1377,1,0,0,0,1377,1378,1,0,0,0,1378,1379,5,133,0,0,
        1379,1380,5,219,0,0,1380,1382,3,260,130,0,1381,1383,3,282,141,0,
        1382,1381,1,0,0,0,1382,1383,1,0,0,0,1383,1388,1,0,0,0,1384,1386,
        5,219,0,0,1385,1384,1,0,0,0,1385,1386,1,0,0,0,1386,1387,1,0,0,0,
        1387,1389,3,250,125,0,1388,1385,1,0,0,0,1388,1389,1,0,0,0,1389,1392,
        1,0,0,0,1390,1391,5,219,0,0,1391,1393,3,262,131,0,1392,1390,1,0,
        0,0,1392,1393,1,0,0,0,1393,1394,1,0,0,0,1394,1396,3,294,147,0,1395,
        1397,3,26,13,0,1396,1395,1,0,0,0,1396,1397,1,0,0,0,1397,1398,1,0,
        0,0,1398,1399,5,57,0,0,1399,141,1,0,0,0,1400,1401,3,284,142,0,1401,
        1402,5,219,0,0,1402,1404,1,0,0,0,1403,1400,1,0,0,0,1403,1404,1,0,
        0,0,1404,1407,1,0,0,0,1405,1406,5,161,0,0,1406,1408,5,219,0,0,1407,
        1405,1,0,0,0,1407,1408,1,0,0,0,1408,1409,1,0,0,0,1409,1410,5,135,
        0,0,1410,1411,5,219,0,0,1411,1416,3,260,130,0,1412,1414,5,219,0,
        0,1413,1412,1,0,0,0,1413,1414,1,0,0,0,1414,1415,1,0,0,0,1415,1417,
        3,250,125,0,1416,1413,1,0,0,0,1416,1417,1,0,0,0,1417,1418,1,0,0,
        0,1418,1420,3,294,147,0,1419,1421,3,26,13,0,1420,1419,1,0,0,0,1420,
        1421,1,0,0,0,1421,1422,1,0,0,0,1422,1423,5,57,0,0,1423,143,1,0,0,
        0,1424,1425,3,284,142,0,1425,1426,5,219,0,0,1426,1428,1,0,0,0,1427,
        1424,1,0,0,0,1427,1428,1,0,0,0,1428,1431,1,0,0,0,1429,1430,5,161,
        0,0,1430,1432,5,219,0,0,1431,1429,1,0,0,0,1431,1432,1,0,0,0,1432,
        1433,1,0,0,0,1433,1434,5,134,0,0,1434,1435,5,219,0,0,1435,1440,3,
        260,130,0,1436,1438,5,219,0,0,1437,1436,1,0,0,0,1437,1438,1,0,0,
        0,1438,1439,1,0,0,0,1439,1441,3,250,125,0,1440,1437,1,0,0,0,1440,
        1441,1,0,0,0,1441,1442,1,0,0,0,1442,1444,3,294,147,0,1443,1445,3,
        26,13,0,1444,1443,1,0,0,0,1444,1445,1,0,0,0,1445,1446,1,0,0,0,1446,
        1447,5,57,0,0,1447,145,1,0,0,0,1448,1449,5,138,0,0,1449,1450,5,219,
        0,0,1450,1452,3,218,109,0,1451,1453,5,219,0,0,1452,1451,1,0,0,0,
        1452,1453,1,0,0,0,1453,1454,1,0,0,0,1454,1456,5,1,0,0,1455,1457,
        5,219,0,0,1456,1455,1,0,0,0,1456,1457,1,0,0,0,1457,1459,1,0,0,0,
        1458,1460,3,202,101,0,1459,1458,1,0,0,0,1459,1460,1,0,0,0,1460,1462,
        1,0,0,0,1461,1463,5,219,0,0,1462,1461,1,0,0,0,1462,1463,1,0,0,0,
        1463,1464,1,0,0,0,1464,1466,5,1,0,0,1465,1467,5,219,0,0,1466,1465,
        1,0,0,0,1466,1467,1,0,0,0,1467,1468,1,0,0,0,1468,1469,3,202,101,
        0,1469,147,1,0,0,0,1470,1471,5,141,0,0,1471,1472,5,219,0,0,1472,
        1487,3,260,130,0,1473,1475,5,219,0,0,1474,1473,1,0,0,0,1474,1475,
        1,0,0,0,1475,1476,1,0,0,0,1476,1478,5,193,0,0,1477,1479,5,219,0,
        0,1478,1477,1,0,0,0,1478,1479,1,0,0,0,1479,1484,1,0,0,0,1480,1482,
        3,244,122,0,1481,1483,5,219,0,0,1482,1481,1,0,0,0,1482,1483,1,0,
        0,0,1483,1485,1,0,0,0,1484,1480,1,0,0,0,1484,1485,1,0,0,0,1485,1486,
        1,0,0,0,1486,1488,5,202,0,0,1487,1474,1,0,0,0,1487,1488,1,0,0,0,
        1488,149,1,0,0,0,1489,1492,5,140,0,0,1490,1491,5,219,0,0,1491,1493,
        3,202,101,0,1492,1490,1,0,0,0,1492,1493,1,0,0,0,1493,151,1,0,0,0,
        1494,1495,5,144,0,0,1495,1498,5,219,0,0,1496,1497,5,130,0,0,1497,
        1499,5,219,0,0,1498,1496,1,0,0,0,1498,1499,1,0,0,0,1499,1500,1,0,
        0,0,1500,1511,3,154,77,0,1501,1503,5,219,0,0,1502,1501,1,0,0,0,1502,
        1503,1,0,0,0,1503,1504,1,0,0,0,1504,1506,5,1,0,0,1505,1507,5,219,
        0,0,1506,1505,1,0,0,0,1506,1507,1,0,0,0,1507,1508,1,0,0,0,1508,1510,
        3,154,77,0,1509,1502,1,0,0,0,1510,1513,1,0,0,0,1511,1509,1,0,0,0,
        1511,1512,1,0,0,0,1512,153,1,0,0,0,1513,1511,1,0,0,0,1514,1516,3,
        232,116,0,1515,1517,5,219,0,0,1516,1515,1,0,0,0,1516,1517,1,0,0,
        0,1517,1518,1,0,0,0,1518,1520,5,193,0,0,1519,1521,5,219,0,0,1520,
        1519,1,0,0,0,1520,1521,1,0,0,0,1521,1522,1,0,0,0,1522,1524,3,256,
        128,0,1523,1525,5,219,0,0,1524,1523,1,0,0,0,1524,1525,1,0,0,0,1525,
        1526,1,0,0,0,1526,1529,5,202,0,0,1527,1528,5,219,0,0,1528,1530,3,
        262,131,0,1529,1527,1,0,0,0,1529,1530,1,0,0,0,1530,155,1,0,0,0,1531,
        1532,5,146,0,0,1532,157,1,0,0,0,1533,1539,5,147,0,0,1534,1537,5,
        219,0,0,1535,1538,5,113,0,0,1536,1538,3,260,130,0,1537,1535,1,0,
        0,0,1537,1536,1,0,0,0,1538,1540,1,0,0,0,1539,1534,1,0,0,0,1539,1540,
        1,0,0,0,1540,159,1,0,0,0,1541,1542,5,148,0,0,1542,161,1,0,0,0,1543,
        1544,5,149,0,0,1544,1545,5,219,0,0,1545,1546,3,202,101,0,1546,163,
        1,0,0,0,1547,1548,5,150,0,0,1548,1549,5,219,0,0,1549,1551,3,232,
        116,0,1550,1552,5,219,0,0,1551,1550,1,0,0,0,1551,1552,1,0,0,0,1552,
        1553,1,0,0,0,1553,1555,5,189,0,0,1554,1556,5,219,0,0,1555,1554,1,
        0,0,0,1555,1556,1,0,0,0,1556,1557,1,0,0,0,1557,1558,3,202,101,0,
        1558,165,1,0,0,0,1559,1560,5,151,0,0,1560,1561,5,219,0,0,1561,1563,
        3,202,101,0,1562,1564,5,219,0,0,1563,1562,1,0,0,0,1563,1564,1,0,
        0,0,1564,1565,1,0,0,0,1565,1567,5,1,0,0,1566,1568,5,219,0,0,1567,
        1566,1,0,0,0,1567,1568,1,0,0,0,1568,1569,1,0,0,0,1569,1570,3,202,
        101,0,1570,167,1,0,0,0,1571,1572,5,152,0,0,1572,1573,5,219,0,0,1573,
        1575,3,202,101,0,1574,1576,5,219,0,0,1575,1574,1,0,0,0,1575,1576,
        1,0,0,0,1576,1577,1,0,0,0,1577,1579,5,1,0,0,1578,1580,5,219,0,0,
        1579,1578,1,0,0,0,1579,1580,1,0,0,0,1580,1581,1,0,0,0,1581,1583,
        3,202,101,0,1582,1584,5,219,0,0,1583,1582,1,0,0,0,1583,1584,1,0,
        0,0,1584,1585,1,0,0,0,1585,1587,5,1,0,0,1586,1588,5,219,0,0,1587,
        1586,1,0,0,0,1587,1588,1,0,0,0,1588,1589,1,0,0,0,1589,1591,3,202,
        101,0,1590,1592,5,219,0,0,1591,1590,1,0,0,0,1591,1592,1,0,0,0,1592,
        1593,1,0,0,0,1593,1595,5,1,0,0,1594,1596,5,219,0,0,1595,1594,1,0,
        0,0,1595,1596,1,0,0,0,1596,1597,1,0,0,0,1597,1598,3,202,101,0,1598,
        169,1,0,0,0,1599,1600,5,153,0,0,1600,1601,5,219,0,0,1601,1603,3,
        218,109,0,1602,1604,5,219,0,0,1603,1602,1,0,0,0,1603,1604,1,0,0,
        0,1604,1605,1,0,0,0,1605,1607,5,1,0,0,1606,1608,5,219,0,0,1607,1606,
        1,0,0,0,1607,1608,1,0,0,0,1608,1609,1,0,0,0,1609,1610,3,202,101,
        0,1610,171,1,0,0,0,1611,1612,5,154,0,0,1612,1613,5,219,0,0,1613,
        1614,5,25,0,0,1614,1615,5,219,0,0,1615,1616,3,202,101,0,1616,1620,
        3,294,147,0,1617,1619,3,176,88,0,1618,1617,1,0,0,0,1619,1622,1,0,
        0,0,1620,1618,1,0,0,0,1620,1621,1,0,0,0,1621,1623,1,0,0,0,1622,1620,
        1,0,0,0,1623,1624,5,58,0,0,1624,173,1,0,0,0,1625,1627,5,87,0,0,1626,
        1628,5,219,0,0,1627,1626,1,0,0,0,1627,1628,1,0,0,0,1628,1629,1,0,
        0,0,1629,1631,3,268,134,0,1630,1632,5,219,0,0,1631,1630,1,0,0,0,
        1631,1632,1,0,0,0,1632,1633,1,0,0,0,1633,1634,3,202,101,0,1634,1643,
        1,0,0,0,1635,1636,3,202,101,0,1636,1637,5,219,0,0,1637,1638,5,170,
        0,0,1638,1639,5,219,0,0,1639,1640,3,202,101,0,1640,1643,1,0,0,0,
        1641,1643,3,202,101,0,1642,1625,1,0,0,0,1642,1635,1,0,0,0,1642,1641,
        1,0,0,0,1643,175,1,0,0,0,1644,1645,5,25,0,0,1645,1646,5,219,0,0,
        1646,1647,3,178,89,0,1647,1649,3,294,147,0,1648,1650,3,26,13,0,1649,
        1648,1,0,0,0,1649,1650,1,0,0,0,1650,177,1,0,0,0,1651,1667,5,52,0,
        0,1652,1663,3,174,87,0,1653,1655,5,219,0,0,1654,1653,1,0,0,0,1654,
        1655,1,0,0,0,1655,1656,1,0,0,0,1656,1658,5,1,0,0,1657,1659,5,219,
        0,0,1658,1657,1,0,0,0,1658,1659,1,0,0,0,1659,1660,1,0,0,0,1660,1662,
        3,174,87,0,1661,1654,1,0,0,0,1662,1665,1,0,0,0,1663,1661,1,0,0,0,
        1663,1664,1,0,0,0,1664,1667,1,0,0,0,1665,1663,1,0,0,0,1666,1651,
        1,0,0,0,1666,1652,1,0,0,0,1667,179,1,0,0,0,1668,1669,5,155,0,0,1669,
        1670,5,219,0,0,1670,1679,3,202,101,0,1671,1673,5,219,0,0,1672,1671,
        1,0,0,0,1672,1673,1,0,0,0,1673,1674,1,0,0,0,1674,1676,5,1,0,0,1675,
        1677,5,219,0,0,1676,1675,1,0,0,0,1676,1677,1,0,0,0,1677,1678,1,0,
        0,0,1678,1680,3,202,101,0,1679,1672,1,0,0,0,1679,1680,1,0,0,0,1680,
        181,1,0,0,0,1681,1682,5,157,0,0,1682,1683,5,219,0,0,1683,1685,3,
        202,101,0,1684,1686,5,219,0,0,1685,1684,1,0,0,0,1685,1686,1,0,0,
        0,1686,1687,1,0,0,0,1687,1689,5,1,0,0,1688,1690,5,219,0,0,1689,1688,
        1,0,0,0,1689,1690,1,0,0,0,1690,1691,1,0,0,0,1691,1692,3,202,101,
        0,1692,183,1,0,0,0,1693,1694,5,156,0,0,1694,1695,5,219,0,0,1695,
        1697,3,232,116,0,1696,1698,5,219,0,0,1697,1696,1,0,0,0,1697,1698,
        1,0,0,0,1698,1699,1,0,0,0,1699,1701,5,189,0,0,1700,1702,5,219,0,
        0,1701,1700,1,0,0,0,1701,1702,1,0,0,0,1702,1703,1,0,0,0,1703,1704,
        3,202,101,0,1704,185,1,0,0,0,1705,1706,5,163,0,0,1706,187,1,0,0,
        0,1707,1708,3,284,142,0,1708,1709,5,219,0,0,1709,1711,1,0,0,0,1710,
        1707,1,0,0,0,1710,1711,1,0,0,0,1711,1714,1,0,0,0,1712,1713,5,161,
        0,0,1713,1715,5,219,0,0,1714,1712,1,0,0,0,1714,1715,1,0,0,0,1715,
        1716,1,0,0,0,1716,1718,5,165,0,0,1717,1719,5,219,0,0,1718,1717,1,
        0,0,0,1718,1719,1,0,0,0,1719,1720,1,0,0,0,1720,1725,3,260,130,0,
        1721,1723,5,219,0,0,1722,1721,1,0,0,0,1722,1723,1,0,0,0,1723,1724,
        1,0,0,0,1724,1726,3,250,125,0,1725,1722,1,0,0,0,1725,1726,1,0,0,
        0,1726,1727,1,0,0,0,1727,1729,3,294,147,0,1728,1730,3,26,13,0,1729,
        1728,1,0,0,0,1729,1730,1,0,0,0,1730,1731,1,0,0,0,1731,1732,5,59,
        0,0,1732,189,1,0,0,0,1733,1735,5,169,0,0,1734,1736,5,219,0,0,1735,
        1734,1,0,0,0,1735,1736,1,0,0,0,1736,1737,1,0,0,0,1737,1739,5,189,
        0,0,1738,1740,5,219,0,0,1739,1738,1,0,0,0,1739,1740,1,0,0,0,1740,
        1741,1,0,0,0,1741,1742,3,202,101,0,1742,191,1,0,0,0,1743,1744,3,
        284,142,0,1744,1745,5,219,0,0,1745,1747,1,0,0,0,1746,1743,1,0,0,
        0,1746,1747,1,0,0,0,1747,1748,1,0,0,0,1748,1749,5,172,0,0,1749,1750,
        5,219,0,0,1750,1751,3,260,130,0,1751,1755,3,294,147,0,1752,1754,
        3,194,97,0,1753,1752,1,0,0,0,1754,1757,1,0,0,0,1755,1753,1,0,0,0,
        1755,1756,1,0,0,0,1756,1758,1,0,0,0,1757,1755,1,0,0,0,1758,1759,
        5,60,0,0,1759,193,1,0,0,0,1760,1775,3,260,130,0,1761,1763,5,219,
        0,0,1762,1761,1,0,0,0,1762,1763,1,0,0,0,1763,1764,1,0,0,0,1764,1769,
        5,193,0,0,1765,1767,5,219,0,0,1766,1765,1,0,0,0,1766,1767,1,0,0,
        0,1767,1768,1,0,0,0,1768,1770,3,256,128,0,1769,1766,1,0,0,0,1769,
        1770,1,0,0,0,1770,1772,1,0,0,0,1771,1773,5,219,0,0,1772,1771,1,0,
        0,0,1772,1773,1,0,0,0,1773,1774,1,0,0,0,1774,1776,5,202,0,0,1775,
        1762,1,0,0,0,1775,1776,1,0,0,0,1776,1779,1,0,0,0,1777,1778,5,219,
        0,0,1778,1780,3,262,131,0,1779,1777,1,0,0,0,1779,1780,1,0,0,0,1780,
        1781,1,0,0,0,1781,1782,3,294,147,0,1782,195,1,0,0,0,1783,1784,5,
        173,0,0,1784,1785,5,219,0,0,1785,1790,3,202,101,0,1786,1787,5,219,
        0,0,1787,1788,5,87,0,0,1788,1789,5,219,0,0,1789,1791,3,280,140,0,
        1790,1786,1,0,0,0,1790,1791,1,0,0,0,1791,197,1,0,0,0,1792,1793,5,
        174,0,0,1793,1794,5,219,0,0,1794,1795,3,202,101,0,1795,199,1,0,0,
        0,1796,1797,5,175,0,0,1797,1798,5,219,0,0,1798,1813,3,218,109,0,
        1799,1801,5,219,0,0,1800,1799,1,0,0,0,1800,1801,1,0,0,0,1801,1802,
        1,0,0,0,1802,1804,5,1,0,0,1803,1805,5,219,0,0,1804,1803,1,0,0,0,
        1804,1805,1,0,0,0,1805,1806,1,0,0,0,1806,1811,3,202,101,0,1807,1808,
        5,219,0,0,1808,1809,5,170,0,0,1809,1810,5,219,0,0,1810,1812,3,202,
        101,0,1811,1807,1,0,0,0,1811,1812,1,0,0,0,1812,1814,1,0,0,0,1813,
        1800,1,0,0,0,1813,1814,1,0,0,0,1814,201,1,0,0,0,1815,1816,6,101,
        -1,0,1816,1876,3,278,139,0,1817,1876,3,232,116,0,1818,1820,5,193,
        0,0,1819,1821,5,219,0,0,1820,1819,1,0,0,0,1820,1821,1,0,0,0,1821,
        1822,1,0,0,0,1822,1833,3,202,101,0,1823,1825,5,219,0,0,1824,1823,
        1,0,0,0,1824,1825,1,0,0,0,1825,1826,1,0,0,0,1826,1828,5,1,0,0,1827,
        1829,5,219,0,0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829,1830,1,0,
        0,0,1830,1832,3,202,101,0,1831,1824,1,0,0,0,1832,1835,1,0,0,0,1833,
        1831,1,0,0,0,1833,1834,1,0,0,0,1834,1836,1,0,0,0,1835,1833,1,0,0,
        0,1836,1837,5,202,0,0,1837,1876,1,0,0,0,1838,1840,5,114,0,0,1839,
        1841,5,219,0,0,1840,1839,1,0,0,0,1840,1841,1,0,0,0,1841,1842,1,0,
        0,0,1842,1876,3,202,101,19,1843,1876,3,196,98,0,1844,1876,3,120,
        60,0,1845,1847,5,10,0,0,1846,1848,5,219,0,0,1847,1846,1,0,0,0,1847,
        1848,1,0,0,0,1848,1849,1,0,0,0,1849,1876,3,202,101,16,1850,1852,
        3,232,116,0,1851,1853,5,219,0,0,1852,1851,1,0,0,0,1852,1853,1,0,
        0,0,1853,1854,1,0,0,0,1854,1856,5,187,0,0,1855,1857,5,219,0,0,1856,
        1855,1,0,0,0,1856,1857,1,0,0,0,1857,1858,1,0,0,0,1858,1859,3,202,
        101,15,1859,1876,1,0,0,0,1860,1862,5,195,0,0,1861,1863,5,219,0,0,
        1862,1861,1,0,0,0,1862,1863,1,0,0,0,1863,1864,1,0,0,0,1864,1876,
        3,202,101,13,1865,1867,5,199,0,0,1866,1868,5,219,0,0,1867,1866,1,
        0,0,0,1867,1868,1,0,0,0,1868,1869,1,0,0,0,1869,1876,3,202,101,12,
        1870,1872,5,115,0,0,1871,1873,5,219,0,0,1872,1871,1,0,0,0,1872,1873,
        1,0,0,0,1873,1874,1,0,0,0,1874,1876,3,202,101,6,1875,1815,1,0,0,
        0,1875,1817,1,0,0,0,1875,1818,1,0,0,0,1875,1838,1,0,0,0,1875,1843,
        1,0,0,0,1875,1844,1,0,0,0,1875,1845,1,0,0,0,1875,1850,1,0,0,0,1875,
        1860,1,0,0,0,1875,1865,1,0,0,0,1875,1870,1,0,0,0,1876,1978,1,0,0,
        0,1877,1879,10,14,0,0,1878,1880,5,219,0,0,1879,1878,1,0,0,0,1879,
        1880,1,0,0,0,1880,1881,1,0,0,0,1881,1883,5,201,0,0,1882,1884,5,219,
        0,0,1883,1882,1,0,0,0,1883,1884,1,0,0,0,1884,1885,1,0,0,0,1885,1977,
        3,202,101,15,1886,1888,10,11,0,0,1887,1889,5,219,0,0,1888,1887,1,
        0,0,0,1888,1889,1,0,0,0,1889,1890,1,0,0,0,1890,1892,7,12,0,0,1891,
        1893,5,219,0,0,1892,1891,1,0,0,0,1892,1893,1,0,0,0,1893,1894,1,0,
        0,0,1894,1977,3,202,101,12,1895,1897,10,10,0,0,1896,1898,5,219,0,
        0,1897,1896,1,0,0,0,1897,1898,1,0,0,0,1898,1899,1,0,0,0,1899,1901,
        5,111,0,0,1900,1902,5,219,0,0,1901,1900,1,0,0,0,1901,1902,1,0,0,
        0,1902,1903,1,0,0,0,1903,1977,3,202,101,11,1904,1906,10,9,0,0,1905,
        1907,5,219,0,0,1906,1905,1,0,0,0,1906,1907,1,0,0,0,1907,1908,1,0,
        0,0,1908,1910,7,13,0,0,1909,1911,5,219,0,0,1910,1909,1,0,0,0,1910,
        1911,1,0,0,0,1911,1912,1,0,0,0,1912,1977,3,202,101,10,1913,1915,
        10,8,0,0,1914,1916,5,219,0,0,1915,1914,1,0,0,0,1915,1916,1,0,0,0,
        1916,1917,1,0,0,0,1917,1919,5,186,0,0,1918,1920,5,219,0,0,1919,1918,
        1,0,0,0,1919,1920,1,0,0,0,1920,1921,1,0,0,0,1921,1977,3,202,101,
        9,1922,1924,10,7,0,0,1923,1925,5,219,0,0,1924,1923,1,0,0,0,1924,
        1925,1,0,0,0,1925,1926,1,0,0,0,1926,1928,7,14,0,0,1927,1929,5,219,
        0,0,1928,1927,1,0,0,0,1928,1929,1,0,0,0,1929,1930,1,0,0,0,1930,1977,
        3,202,101,8,1931,1933,10,5,0,0,1932,1934,5,219,0,0,1933,1932,1,0,
        0,0,1933,1934,1,0,0,0,1934,1935,1,0,0,0,1935,1937,5,12,0,0,1936,
        1938,5,219,0,0,1937,1936,1,0,0,0,1937,1938,1,0,0,0,1938,1939,1,0,
        0,0,1939,1977,3,202,101,6,1940,1942,10,4,0,0,1941,1943,5,219,0,0,
        1942,1941,1,0,0,0,1942,1943,1,0,0,0,1943,1944,1,0,0,0,1944,1946,
        5,127,0,0,1945,1947,5,219,0,0,1946,1945,1,0,0,0,1946,1947,1,0,0,
        0,1947,1948,1,0,0,0,1948,1977,3,202,101,5,1949,1951,10,3,0,0,1950,
        1952,5,219,0,0,1951,1950,1,0,0,0,1951,1952,1,0,0,0,1952,1953,1,0,
        0,0,1953,1955,5,185,0,0,1954,1956,5,219,0,0,1955,1954,1,0,0,0,1955,
        1956,1,0,0,0,1956,1957,1,0,0,0,1957,1977,3,202,101,4,1958,1960,10,
        2,0,0,1959,1961,5,219,0,0,1960,1959,1,0,0,0,1960,1961,1,0,0,0,1961,
        1962,1,0,0,0,1962,1964,5,64,0,0,1963,1965,5,219,0,0,1964,1963,1,
        0,0,0,1964,1965,1,0,0,0,1965,1966,1,0,0,0,1966,1977,3,202,101,3,
        1967,1969,10,1,0,0,1968,1970,5,219,0,0,1969,1968,1,0,0,0,1969,1970,
        1,0,0,0,1970,1971,1,0,0,0,1971,1973,5,83,0,0,1972,1974,5,219,0,0,
        1973,1972,1,0,0,0,1973,1974,1,0,0,0,1974,1975,1,0,0,0,1975,1977,
        3,202,101,2,1976,1877,1,0,0,0,1976,1886,1,0,0,0,1976,1895,1,0,0,
        0,1976,1904,1,0,0,0,1976,1913,1,0,0,0,1976,1922,1,0,0,0,1976,1931,
        1,0,0,0,1976,1940,1,0,0,0,1976,1949,1,0,0,0,1976,1958,1,0,0,0,1976,
        1967,1,0,0,0,1977,1980,1,0,0,0,1978,1976,1,0,0,0,1978,1979,1,0,0,
        0,1979,203,1,0,0,0,1980,1978,1,0,0,0,1981,1985,5,48,0,0,1982,1985,
        5,161,0,0,1983,1985,3,284,142,0,1984,1981,1,0,0,0,1984,1982,1,0,
        0,0,1984,1983,1,0,0,0,1985,1986,1,0,0,0,1986,1989,5,219,0,0,1987,
        1988,5,183,0,0,1988,1990,5,219,0,0,1989,1987,1,0,0,0,1989,1990,1,
        0,0,0,1990,1991,1,0,0,0,1991,1992,3,206,103,0,1992,205,1,0,0,0,1993,
        2004,3,208,104,0,1994,1996,5,219,0,0,1995,1994,1,0,0,0,1995,1996,
        1,0,0,0,1996,1997,1,0,0,0,1997,1999,5,1,0,0,1998,2000,5,219,0,0,
        1999,1998,1,0,0,0,1999,2000,1,0,0,0,2000,2001,1,0,0,0,2001,2003,
        3,208,104,0,2002,1995,1,0,0,0,2003,2006,1,0,0,0,2004,2002,1,0,0,
        0,2004,2005,1,0,0,0,2005,207,1,0,0,0,2006,2004,1,0,0,0,2007,2025,
        3,260,130,0,2008,2010,5,219,0,0,2009,2008,1,0,0,0,2009,2010,1,0,
        0,0,2010,2011,1,0,0,0,2011,2013,5,193,0,0,2012,2014,5,219,0,0,2013,
        2012,1,0,0,0,2013,2014,1,0,0,0,2014,2019,1,0,0,0,2015,2017,3,256,
        128,0,2016,2018,5,219,0,0,2017,2016,1,0,0,0,2017,2018,1,0,0,0,2018,
        2020,1,0,0,0,2019,2015,1,0,0,0,2019,2020,1,0,0,0,2020,2021,1,0,0,
        0,2021,2023,5,202,0,0,2022,2024,5,219,0,0,2023,2022,1,0,0,0,2023,
        2024,1,0,0,0,2024,2026,1,0,0,0,2025,2009,1,0,0,0,2025,2026,1,0,0,
        0,2026,2028,1,0,0,0,2027,2029,3,282,141,0,2028,2027,1,0,0,0,2028,
        2029,1,0,0,0,2029,2032,1,0,0,0,2030,2031,5,219,0,0,2031,2033,3,262,
        131,0,2032,2030,1,0,0,0,2032,2033,1,0,0,0,2033,209,1,0,0,0,2034,
        2035,5,180,0,0,2035,2036,5,219,0,0,2036,2037,3,202,101,0,2037,2039,
        3,294,147,0,2038,2040,3,26,13,0,2039,2038,1,0,0,0,2039,2040,1,0,
        0,0,2040,2041,1,0,0,0,2041,2042,5,179,0,0,2042,211,1,0,0,0,2043,
        2044,5,181,0,0,2044,2045,5,219,0,0,2045,2047,3,218,109,0,2046,2048,
        5,219,0,0,2047,2046,1,0,0,0,2047,2048,1,0,0,0,2048,2049,1,0,0,0,
        2049,2051,5,1,0,0,2050,2052,5,219,0,0,2051,2050,1,0,0,0,2051,2052,
        1,0,0,0,2052,2053,1,0,0,0,2053,2054,3,202,101,0,2054,213,1,0,0,0,
        2055,2056,5,182,0,0,2056,2061,5,219,0,0,2057,2062,3,232,116,0,2058,
        2059,5,114,0,0,2059,2060,5,219,0,0,2060,2062,3,280,140,0,2061,2057,
        1,0,0,0,2061,2058,1,0,0,0,2062,2063,1,0,0,0,2063,2065,3,294,147,
        0,2064,2066,3,26,13,0,2065,2064,1,0,0,0,2065,2066,1,0,0,0,2066,2067,
        1,0,0,0,2067,2068,5,61,0,0,2068,215,1,0,0,0,2069,2070,5,184,0,0,
        2070,2071,5,219,0,0,2071,2073,3,218,109,0,2072,2074,5,219,0,0,2073,
        2072,1,0,0,0,2073,2074,1,0,0,0,2074,2075,1,0,0,0,2075,2080,5,1,0,
        0,2076,2078,5,219,0,0,2077,2076,1,0,0,0,2077,2078,1,0,0,0,2078,2079,
        1,0,0,0,2079,2081,3,134,67,0,2080,2077,1,0,0,0,2080,2081,1,0,0,0,
        2081,217,1,0,0,0,2082,2084,5,3,0,0,2083,2082,1,0,0,0,2083,2084,1,
        0,0,0,2084,2085,1,0,0,0,2085,2086,3,202,101,0,2086,219,1,0,0,0,2087,
        2090,3,222,111,0,2088,2090,3,224,112,0,2089,2087,1,0,0,0,2089,2088,
        1,0,0,0,2090,221,1,0,0,0,2091,2092,5,24,0,0,2092,2093,5,219,0,0,
        2093,2095,3,260,130,0,2094,2096,3,282,141,0,2095,2094,1,0,0,0,2095,
        2096,1,0,0,0,2096,2110,1,0,0,0,2097,2099,5,219,0,0,2098,2097,1,0,
        0,0,2098,2099,1,0,0,0,2099,2100,1,0,0,0,2100,2102,5,193,0,0,2101,
        2103,5,219,0,0,2102,2101,1,0,0,0,2102,2103,1,0,0,0,2103,2104,1,0,
        0,0,2104,2106,3,244,122,0,2105,2107,5,219,0,0,2106,2105,1,0,0,0,
        2106,2107,1,0,0,0,2107,2108,1,0,0,0,2108,2109,5,202,0,0,2109,2111,
        1,0,0,0,2110,2098,1,0,0,0,2110,2111,1,0,0,0,2111,2121,1,0,0,0,2112,
        2114,5,219,0,0,2113,2112,1,0,0,0,2113,2114,1,0,0,0,2114,2115,1,0,
        0,0,2115,2116,5,193,0,0,2116,2117,3,256,128,0,2117,2118,5,202,0,
        0,2118,2120,1,0,0,0,2119,2113,1,0,0,0,2120,2123,1,0,0,0,2121,2119,
        1,0,0,0,2121,2122,1,0,0,0,2122,223,1,0,0,0,2123,2121,1,0,0,0,2124,
        2125,5,24,0,0,2125,2127,5,219,0,0,2126,2128,3,232,116,0,2127,2126,
        1,0,0,0,2127,2128,1,0,0,0,2128,2129,1,0,0,0,2129,2130,5,4,0,0,2130,
        2132,3,260,130,0,2131,2133,3,282,141,0,2132,2131,1,0,0,0,2132,2133,
        1,0,0,0,2133,2147,1,0,0,0,2134,2136,5,219,0,0,2135,2134,1,0,0,0,
        2135,2136,1,0,0,0,2136,2137,1,0,0,0,2137,2139,5,193,0,0,2138,2140,
        5,219,0,0,2139,2138,1,0,0,0,2139,2140,1,0,0,0,2140,2141,1,0,0,0,
        2141,2143,3,244,122,0,2142,2144,5,219,0,0,2143,2142,1,0,0,0,2143,
        2144,1,0,0,0,2144,2145,1,0,0,0,2145,2146,5,202,0,0,2146,2148,1,0,
        0,0,2147,2135,1,0,0,0,2147,2148,1,0,0,0,2148,2158,1,0,0,0,2149,2151,
        5,219,0,0,2150,2149,1,0,0,0,2150,2151,1,0,0,0,2151,2152,1,0,0,0,
        2152,2153,5,193,0,0,2153,2154,3,256,128,0,2154,2155,5,202,0,0,2155,
        2157,1,0,0,0,2156,2150,1,0,0,0,2157,2160,1,0,0,0,2158,2156,1,0,0,
        0,2158,2159,1,0,0,0,2159,225,1,0,0,0,2160,2158,1,0,0,0,2161,2164,
        3,228,114,0,2162,2164,3,230,115,0,2163,2161,1,0,0,0,2163,2162,1,
        0,0,0,2164,227,1,0,0,0,2165,2167,3,232,116,0,2166,2165,1,0,0,0,2166,
        2167,1,0,0,0,2167,2168,1,0,0,0,2168,2169,5,4,0,0,2169,2171,3,260,
        130,0,2170,2172,3,282,141,0,2171,2170,1,0,0,0,2171,2172,1,0,0,0,
        2172,2175,1,0,0,0,2173,2174,5,219,0,0,2174,2176,3,244,122,0,2175,
        2173,1,0,0,0,2175,2176,1,0,0,0,2176,2178,1,0,0,0,2177,2179,3,248,
        124,0,2178,2177,1,0,0,0,2178,2179,1,0,0,0,2179,2189,1,0,0,0,2180,
        2182,5,219,0,0,2181,2180,1,0,0,0,2181,2182,1,0,0,0,2182,2183,1,0,
        0,0,2183,2184,5,193,0,0,2184,2185,3,256,128,0,2185,2186,5,202,0,
        0,2186,2188,1,0,0,0,2187,2181,1,0,0,0,2188,2191,1,0,0,0,2189,2187,
        1,0,0,0,2189,2190,1,0,0,0,2190,229,1,0,0,0,2191,2189,1,0,0,0,2192,
        2195,3,266,133,0,2193,2194,5,219,0,0,2194,2196,3,244,122,0,2195,
        2193,1,0,0,0,2195,2196,1,0,0,0,2196,2206,1,0,0,0,2197,2199,5,219,
        0,0,2198,2197,1,0,0,0,2198,2199,1,0,0,0,2199,2200,1,0,0,0,2200,2201,
        5,193,0,0,2201,2202,3,256,128,0,2202,2203,5,202,0,0,2203,2205,1,
        0,0,0,2204,2198,1,0,0,0,2205,2208,1,0,0,0,2206,2204,1,0,0,0,2206,
        2207,1,0,0,0,2207,231,1,0,0,0,2208,2206,1,0,0,0,2209,2214,3,238,
        119,0,2210,2214,3,234,117,0,2211,2214,3,236,118,0,2212,2214,3,242,
        121,0,2213,2209,1,0,0,0,2213,2210,1,0,0,0,2213,2211,1,0,0,0,2213,
        2212,1,0,0,0,2214,233,1,0,0,0,2215,2217,3,260,130,0,2216,2218,3,
        282,141,0,2217,2216,1,0,0,0,2217,2218,1,0,0,0,2218,2220,1,0,0,0,
        2219,2221,3,248,124,0,2220,2219,1,0,0,0,2220,2221,1,0,0,0,2221,2231,
        1,0,0,0,2222,2224,5,219,0,0,2223,2222,1,0,0,0,2223,2224,1,0,0,0,
        2224,2225,1,0,0,0,2225,2226,5,193,0,0,2226,2227,3,256,128,0,2227,
        2228,5,202,0,0,2228,2230,1,0,0,0,2229,2223,1,0,0,0,2230,2233,1,0,
        0,0,2231,2229,1,0,0,0,2231,2232,1,0,0,0,2232,235,1,0,0,0,2233,2231,
        1,0,0,0,2234,2237,3,260,130,0,2235,2237,3,264,132,0,2236,2234,1,
        0,0,0,2236,2235,1,0,0,0,2237,2239,1,0,0,0,2238,2240,3,282,141,0,
        2239,2238,1,0,0,0,2239,2240,1,0,0,0,2240,2242,1,0,0,0,2241,2243,
        5,219,0,0,2242,2241,1,0,0,0,2242,2243,1,0,0,0,2243,2244,1,0,0,0,
        2244,2246,5,193,0,0,2245,2247,5,219,0,0,2246,2245,1,0,0,0,2246,2247,
        1,0,0,0,2247,2252,1,0,0,0,2248,2250,3,244,122,0,2249,2251,5,219,
        0,0,2250,2249,1,0,0,0,2250,2251,1,0,0,0,2251,2253,1,0,0,0,2252,2248,
        1,0,0,0,2252,2253,1,0,0,0,2253,2254,1,0,0,0,2254,2256,5,202,0,0,
        2255,2257,3,248,124,0,2256,2255,1,0,0,0,2256,2257,1,0,0,0,2257,2267,
        1,0,0,0,2258,2260,5,219,0,0,2259,2258,1,0,0,0,2259,2260,1,0,0,0,
        2260,2261,1,0,0,0,2261,2262,5,193,0,0,2262,2263,3,256,128,0,2263,
        2264,5,202,0,0,2264,2266,1,0,0,0,2265,2259,1,0,0,0,2266,2269,1,0,
        0,0,2267,2265,1,0,0,0,2267,2268,1,0,0,0,2268,237,1,0,0,0,2269,2267,
        1,0,0,0,2270,2273,3,234,117,0,2271,2273,3,236,118,0,2272,2270,1,
        0,0,0,2272,2271,1,0,0,0,2272,2273,1,0,0,0,2273,2275,1,0,0,0,2274,
        2276,3,240,120,0,2275,2274,1,0,0,0,2276,2277,1,0,0,0,2277,2275,1,
        0,0,0,2277,2278,1,0,0,0,2278,2280,1,0,0,0,2279,2281,3,248,124,0,
        2280,2279,1,0,0,0,2280,2281,1,0,0,0,2281,2291,1,0,0,0,2282,2284,
        5,219,0,0,2283,2282,1,0,0,0,2283,2284,1,0,0,0,2284,2285,1,0,0,0,
        2285,2286,5,193,0,0,2286,2287,3,256,128,0,2287,2288,5,202,0,0,2288,
        2290,1,0,0,0,2289,2283,1,0,0,0,2290,2293,1,0,0,0,2291,2289,1,0,0,
        0,2291,2292,1,0,0,0,2292,239,1,0,0,0,2293,2291,1,0,0,0,2294,2296,
        5,212,0,0,2295,2294,1,0,0,0,2295,2296,1,0,0,0,2296,2297,1,0,0,0,
        2297,2299,7,15,0,0,2298,2300,5,212,0,0,2299,2298,1,0,0,0,2299,2300,
        1,0,0,0,2300,2303,1,0,0,0,2301,2304,3,234,117,0,2302,2304,3,236,
        118,0,2303,2301,1,0,0,0,2303,2302,1,0,0,0,2304,241,1,0,0,0,2305,
        2306,3,248,124,0,2306,243,1,0,0,0,2307,2309,3,246,123,0,2308,2307,
        1,0,0,0,2308,2309,1,0,0,0,2309,2311,1,0,0,0,2310,2312,5,219,0,0,
        2311,2310,1,0,0,0,2311,2312,1,0,0,0,2312,2313,1,0,0,0,2313,2315,
        7,10,0,0,2314,2316,5,219,0,0,2315,2314,1,0,0,0,2315,2316,1,0,0,0,
        2316,2318,1,0,0,0,2317,2308,1,0,0,0,2318,2321,1,0,0,0,2319,2317,
        1,0,0,0,2319,2320,1,0,0,0,2320,2322,1,0,0,0,2321,2319,1,0,0,0,2322,
        2335,3,246,123,0,2323,2325,5,219,0,0,2324,2323,1,0,0,0,2324,2325,
        1,0,0,0,2325,2326,1,0,0,0,2326,2328,7,10,0,0,2327,2329,5,219,0,0,
        2328,2327,1,0,0,0,2328,2329,1,0,0,0,2329,2331,1,0,0,0,2330,2332,
        3,246,123,0,2331,2330,1,0,0,0,2331,2332,1,0,0,0,2332,2334,1,0,0,
        0,2333,2324,1,0,0,0,2334,2337,1,0,0,0,2335,2333,1,0,0,0,2335,2336,
        1,0,0,0,2336,245,1,0,0,0,2337,2335,1,0,0,0,2338,2340,5,193,0,0,2339,
        2338,1,0,0,0,2339,2340,1,0,0,0,2340,2343,1,0,0,0,2341,2342,7,16,
        0,0,2342,2344,5,219,0,0,2343,2341,1,0,0,0,2343,2344,1,0,0,0,2344,
        2346,1,0,0,0,2345,2347,5,202,0,0,2346,2345,1,0,0,0,2346,2347,1,0,
        0,0,2347,2348,1,0,0,0,2348,2349,3,202,101,0,2349,247,1,0,0,0,2350,
        2351,5,5,0,0,2351,2353,3,260,130,0,2352,2354,3,282,141,0,2353,2352,
        1,0,0,0,2353,2354,1,0,0,0,2354,249,1,0,0,0,2355,2373,5,193,0,0,2356,
        2358,5,219,0,0,2357,2356,1,0,0,0,2357,2358,1,0,0,0,2358,2359,1,0,
        0,0,2359,2370,3,252,126,0,2360,2362,5,219,0,0,2361,2360,1,0,0,0,
        2361,2362,1,0,0,0,2362,2363,1,0,0,0,2363,2365,5,1,0,0,2364,2366,
        5,219,0,0,2365,2364,1,0,0,0,2365,2366,1,0,0,0,2366,2367,1,0,0,0,
        2367,2369,3,252,126,0,2368,2361,1,0,0,0,2369,2372,1,0,0,0,2370,2368,
        1,0,0,0,2370,2371,1,0,0,0,2371,2374,1,0,0,0,2372,2370,1,0,0,0,2373,
        2357,1,0,0,0,2373,2374,1,0,0,0,2374,2376,1,0,0,0,2375,2377,5,219,
        0,0,2376,2375,1,0,0,0,2376,2377,1,0,0,0,2377,2378,1,0,0,0,2378,2379,
        5,202,0,0,2379,251,1,0,0,0,2380,2381,5,122,0,0,2381,2383,5,219,0,
        0,2382,2380,1,0,0,0,2382,2383,1,0,0,0,2383,2386,1,0,0,0,2384,2385,
        7,17,0,0,2385,2387,5,219,0,0,2386,2384,1,0,0,0,2386,2387,1,0,0,0,
        2387,2390,1,0,0,0,2388,2389,5,129,0,0,2389,2391,5,219,0,0,2390,2388,
        1,0,0,0,2390,2391,1,0,0,0,2391,2392,1,0,0,0,2392,2394,3,260,130,
        0,2393,2395,3,282,141,0,2394,2393,1,0,0,0,2394,2395,1,0,0,0,2395,
        2404,1,0,0,0,2396,2398,5,219,0,0,2397,2396,1,0,0,0,2397,2398,1,0,
        0,0,2398,2399,1,0,0,0,2399,2401,5,193,0,0,2400,2402,5,219,0,0,2401,
        2400,1,0,0,0,2401,2402,1,0,0,0,2402,2403,1,0,0,0,2403,2405,5,202,
        0,0,2404,2397,1,0,0,0,2404,2405,1,0,0,0,2405,2410,1,0,0,0,2406,2408,
        5,219,0,0,2407,2406,1,0,0,0,2407,2408,1,0,0,0,2408,2409,1,0,0,0,
        2409,2411,3,262,131,0,2410,2407,1,0,0,0,2410,2411,1,0,0,0,2411,2416,
        1,0,0,0,2412,2414,5,219,0,0,2413,2412,1,0,0,0,2413,2414,1,0,0,0,
        2414,2415,1,0,0,0,2415,2417,3,254,127,0,2416,2413,1,0,0,0,2416,2417,
        1,0,0,0,2417,253,1,0,0,0,2418,2420,5,189,0,0,2419,2421,5,219,0,0,
        2420,2419,1,0,0,0,2420,2421,1,0,0,0,2421,2422,1,0,0,0,2422,2423,
        3,202,101,0,2423,255,1,0,0,0,2424,2435,3,258,129,0,2425,2427,5,219,
        0,0,2426,2425,1,0,0,0,2426,2427,1,0,0,0,2427,2428,1,0,0,0,2428,2430,
        5,1,0,0,2429,2431,5,219,0,0,2430,2429,1,0,0,0,2430,2431,1,0,0,0,
        2431,2432,1,0,0,0,2432,2434,3,258,129,0,2433,2426,1,0,0,0,2434,2437,
        1,0,0,0,2435,2433,1,0,0,0,2435,2436,1,0,0,0,2436,257,1,0,0,0,2437,
        2435,1,0,0,0,2438,2439,3,202,101,0,2439,2440,5,219,0,0,2440,2441,
        5,170,0,0,2441,2442,5,219,0,0,2442,2444,1,0,0,0,2443,2438,1,0,0,
        0,2443,2444,1,0,0,0,2444,2445,1,0,0,0,2445,2446,3,202,101,0,2446,
        259,1,0,0,0,2447,2450,5,220,0,0,2448,2450,3,286,143,0,2449,2447,
        1,0,0,0,2449,2448,1,0,0,0,2450,2451,1,0,0,0,2451,2449,1,0,0,0,2451,
        2452,1,0,0,0,2452,261,1,0,0,0,2453,2455,5,16,0,0,2454,2456,5,219,
        0,0,2455,2454,1,0,0,0,2455,2456,1,0,0,0,2456,2459,1,0,0,0,2457,2458,
        5,114,0,0,2458,2460,5,219,0,0,2459,2457,1,0,0,0,2459,2460,1,0,0,
        0,2460,2461,1,0,0,0,2461,2466,3,280,140,0,2462,2464,5,219,0,0,2463,
        2462,1,0,0,0,2463,2464,1,0,0,0,2464,2465,1,0,0,0,2465,2467,3,272,
        136,0,2466,2463,1,0,0,0,2466,2467,1,0,0,0,2467,263,1,0,0,0,2468,
        2489,5,20,0,0,2469,2489,5,23,0,0,2470,2489,5,30,0,0,2471,2489,5,
        33,0,0,2472,2489,5,50,0,0,2473,2489,5,88,0,0,2474,2489,5,92,0,0,
        2475,2489,5,159,0,0,2476,2485,5,164,0,0,2477,2479,5,219,0,0,2478,
        2477,1,0,0,0,2478,2479,1,0,0,0,2479,2480,1,0,0,0,2480,2482,5,197,
        0,0,2481,2483,5,219,0,0,2482,2481,1,0,0,0,2482,2483,1,0,0,0,2483,
        2484,1,0,0,0,2484,2486,3,202,101,0,2485,2478,1,0,0,0,2485,2486,1,
        0,0,0,2486,2489,1,0,0,0,2487,2489,5,177,0,0,2488,2468,1,0,0,0,2488,
        2469,1,0,0,0,2488,2470,1,0,0,0,2488,2471,1,0,0,0,2488,2472,1,0,0,
        0,2488,2473,1,0,0,0,2488,2474,1,0,0,0,2488,2475,1,0,0,0,2488,2476,
        1,0,0,0,2488,2487,1,0,0,0,2489,265,1,0,0,0,2490,2495,5,220,0,0,2491,
        2494,3,286,143,0,2492,2494,5,220,0,0,2493,2491,1,0,0,0,2493,2492,
        1,0,0,0,2494,2497,1,0,0,0,2495,2493,1,0,0,0,2495,2496,1,0,0,0,2496,
        2506,1,0,0,0,2497,2495,1,0,0,0,2498,2501,3,286,143,0,2499,2502,3,
        286,143,0,2500,2502,5,220,0,0,2501,2499,1,0,0,0,2501,2500,1,0,0,
        0,2502,2503,1,0,0,0,2503,2501,1,0,0,0,2503,2504,1,0,0,0,2504,2506,
        1,0,0,0,2505,2490,1,0,0,0,2505,2498,1,0,0,0,2506,267,1,0,0,0,2507,
        2508,7,14,0,0,2508,269,1,0,0,0,2509,2514,3,260,130,0,2510,2511,7,
        15,0,0,2511,2513,3,260,130,0,2512,2510,1,0,0,0,2513,2516,1,0,0,0,
        2514,2512,1,0,0,0,2514,2515,1,0,0,0,2515,271,1,0,0,0,2516,2514,1,
        0,0,0,2517,2519,5,197,0,0,2518,2520,5,219,0,0,2519,2518,1,0,0,0,
        2519,2520,1,0,0,0,2520,2523,1,0,0,0,2521,2524,5,209,0,0,2522,2524,
        3,260,130,0,2523,2521,1,0,0,0,2523,2522,1,0,0,0,2524,273,1,0,0,0,
        2525,2534,3,266,133,0,2526,2528,5,219,0,0,2527,2526,1,0,0,0,2527,
        2528,1,0,0,0,2528,2529,1,0,0,0,2529,2531,5,195,0,0,2530,2532,5,219,
        0,0,2531,2530,1,0,0,0,2531,2532,1,0,0,0,2532,2533,1,0,0,0,2533,2535,
        3,266,133,0,2534,2527,1,0,0,0,2534,2535,1,0,0,0,2535,275,1,0,0,0,
        2536,2537,3,260,130,0,2537,2538,5,217,0,0,2538,277,1,0,0,0,2539,
        2540,7,18,0,0,2540,279,1,0,0,0,2541,2544,3,264,132,0,2542,2544,3,
        270,135,0,2543,2541,1,0,0,0,2543,2542,1,0,0,0,2544,2553,1,0,0,0,
        2545,2547,5,219,0,0,2546,2545,1,0,0,0,2546,2547,1,0,0,0,2547,2548,
        1,0,0,0,2548,2550,5,193,0,0,2549,2551,5,219,0,0,2550,2549,1,0,0,
        0,2550,2551,1,0,0,0,2551,2552,1,0,0,0,2552,2554,5,202,0,0,2553,2546,
        1,0,0,0,2553,2554,1,0,0,0,2554,281,1,0,0,0,2555,2556,7,19,0,0,2556,
        283,1,0,0,0,2557,2558,7,20,0,0,2558,285,1,0,0,0,2559,2560,7,21,0,
        0,2560,287,1,0,0,0,2561,2562,5,214,0,0,2562,289,1,0,0,0,2563,2564,
        5,215,0,0,2564,291,1,0,0,0,2565,2567,5,219,0,0,2566,2565,1,0,0,0,
        2566,2567,1,0,0,0,2567,2571,1,0,0,0,2568,2572,5,213,0,0,2569,2572,
        3,290,145,0,2570,2572,3,288,144,0,2571,2568,1,0,0,0,2571,2569,1,
        0,0,0,2571,2570,1,0,0,0,2572,2574,1,0,0,0,2573,2575,5,219,0,0,2574,
        2573,1,0,0,0,2574,2575,1,0,0,0,2575,293,1,0,0,0,2576,2585,3,292,
        146,0,2577,2579,5,219,0,0,2578,2577,1,0,0,0,2578,2579,1,0,0,0,2579,
        2580,1,0,0,0,2580,2582,5,217,0,0,2581,2583,5,219,0,0,2582,2581,1,
        0,0,0,2582,2583,1,0,0,0,2583,2585,1,0,0,0,2584,2576,1,0,0,0,2584,
        2578,1,0,0,0,2585,2588,1,0,0,0,2586,2584,1,0,0,0,2586,2587,1,0,0,
        0,2587,295,1,0,0,0,2588,2586,1,0,0,0,439,300,305,312,315,318,323,
        327,332,336,341,345,350,354,366,372,378,382,388,395,399,405,411,
        417,428,441,445,451,457,463,472,478,482,486,490,495,504,577,583,
        587,590,606,610,615,618,623,629,633,638,643,647,650,654,660,664,
        671,677,681,684,689,699,702,705,709,715,719,724,731,735,739,743,
        746,751,762,775,782,791,798,802,805,814,819,829,835,845,849,859,
        867,872,878,882,885,889,900,904,909,914,918,922,926,929,932,935,
        938,942,950,954,957,960,964,987,993,997,1001,1010,1021,1026,1036,
        1040,1045,1053,1057,1061,1069,1073,1079,1082,1085,1088,1098,1102,
        1109,1111,1117,1121,1127,1131,1135,1143,1147,1153,1162,1164,1169,
        1178,1180,1188,1190,1195,1199,1203,1227,1237,1241,1246,1257,1261,
        1266,1280,1284,1293,1297,1300,1304,1308,1311,1315,1319,1322,1326,
        1329,1333,1335,1340,1344,1348,1352,1354,1360,1364,1367,1372,1376,
        1382,1385,1388,1392,1396,1403,1407,1413,1416,1420,1427,1431,1437,
        1440,1444,1452,1456,1459,1462,1466,1474,1478,1482,1484,1487,1492,
        1498,1502,1506,1511,1516,1520,1524,1529,1537,1539,1551,1555,1563,
        1567,1575,1579,1583,1587,1591,1595,1603,1607,1620,1627,1631,1642,
        1649,1654,1658,1663,1666,1672,1676,1679,1685,1689,1697,1701,1710,
        1714,1718,1722,1725,1729,1735,1739,1746,1755,1762,1766,1769,1772,
        1775,1779,1790,1800,1804,1811,1813,1820,1824,1828,1833,1840,1847,
        1852,1856,1862,1867,1872,1875,1879,1883,1888,1892,1897,1901,1906,
        1910,1915,1919,1924,1928,1933,1937,1942,1946,1951,1955,1960,1964,
        1969,1973,1976,1978,1984,1989,1995,1999,2004,2009,2013,2017,2019,
        2023,2025,2028,2032,2039,2047,2051,2061,2065,2073,2077,2080,2083,
        2089,2095,2098,2102,2106,2110,2113,2121,2127,2132,2135,2139,2143,
        2147,2150,2158,2163,2166,2171,2175,2178,2181,2189,2195,2198,2206,
        2213,2217,2220,2223,2231,2236,2239,2242,2246,2250,2252,2256,2259,
        2267,2272,2277,2280,2283,2291,2295,2299,2303,2308,2311,2315,2319,
        2324,2328,2331,2335,2339,2343,2346,2353,2357,2361,2365,2370,2373,
        2376,2382,2386,2390,2394,2397,2401,2404,2407,2410,2413,2416,2420,
        2426,2430,2435,2443,2449,2451,2455,2459,2463,2466,2478,2482,2485,
        2488,2493,2495,2501,2503,2505,2514,2519,2523,2527,2531,2534,2543,
        2546,2550,2553,2566,2571,2574,2578,2582,2584,2586
    ]

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>", "','", "';'", "'#'", "'.'", "'!'", "'%'", 
                     "'@'", "'$'", "'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'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'END'", "'ENUM'", "'EQV'", 
                     "'ERASE'", "'ERROR'", "'EVENT'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'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'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'LSET'", "'#CONST'", "'#IF'", "'#ELSEIF'", "'#ELSE'", 
                     "<INVALID>", "'ME'", "'MID'", "'MKDIR'", "'MOD'", "'NAME'", 
                     "'NEXT'", "'NEW'", "'NOT'", "'NOTHING'", "'NULL'", 
                     "'ON'", "<INVALID>", "<INVALID>", "'OPEN'", "'OPTIONAL'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'OR'", "'OUTPUT'", "'PARAMARRAY'", "'PRESERVE'", "'PRINT'", 
                     "'PRIVATE'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'PTRSAFE'", "'PUBLIC'", "'PUT'", "'RANDOM'", "'RANDOMIZE'", 
                     "'RAISEEVENT'", "'READ'", "<INVALID>", "'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'", 
                     "'&'", "':='", "<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_lineNumber = 51
    RULE_loadStmt = 52
    RULE_lockStmt = 53
    RULE_lsetStmt = 54
    RULE_macroConstStmt = 55
    RULE_macroIfThenElseStmt = 56
    RULE_macroIfBlockStmt = 57
    RULE_macroElseIfBlockStmt = 58
    RULE_macroElseBlockStmt = 59
    RULE_midStmt = 60
    RULE_mkdirStmt = 61
    RULE_nameStmt = 62
    RULE_onErrorStmt = 63
    RULE_onGoToStmt = 64
    RULE_onGoSubStmt = 65
    RULE_openStmt = 66
    RULE_outputList = 67
    RULE_outputList_Expression = 68
    RULE_printStmt = 69
    RULE_propertyGetStmt = 70
    RULE_propertySetStmt = 71
    RULE_propertyLetStmt = 72
    RULE_putStmt = 73
    RULE_raiseEventStmt = 74
    RULE_randomizeStmt = 75
    RULE_redimStmt = 76
    RULE_redimSubStmt = 77
    RULE_resetStmt = 78
    RULE_resumeStmt = 79
    RULE_returnStmt = 80
    RULE_rmdirStmt = 81
    RULE_rsetStmt = 82
    RULE_savepictureStmt = 83
    RULE_saveSettingStmt = 84
    RULE_seekStmt = 85
    RULE_selectCaseStmt = 86
    RULE_sC_Selection = 87
    RULE_sC_Case = 88
    RULE_sC_Cond = 89
    RULE_sendkeysStmt = 90
    RULE_setattrStmt = 91
    RULE_setStmt = 92
    RULE_stopStmt = 93
    RULE_subStmt = 94
    RULE_timeStmt = 95
    RULE_typeStmt = 96
    RULE_typeStmt_Element = 97
    RULE_typeOfStmt = 98
    RULE_unloadStmt = 99
    RULE_unlockStmt = 100
    RULE_valueStmt = 101
    RULE_variableStmt = 102
    RULE_variableListStmt = 103
    RULE_variableSubStmt = 104
    RULE_whileWendStmt = 105
    RULE_widthStmt = 106
    RULE_withStmt = 107
    RULE_writeStmt = 108
    RULE_fileNumber = 109
    RULE_explicitCallStmt = 110
    RULE_eCS_ProcedureCall = 111
    RULE_eCS_MemberProcedureCall = 112
    RULE_implicitCallStmt_InBlock = 113
    RULE_iCS_B_MemberProcedureCall = 114
    RULE_iCS_B_ProcedureCall = 115
    RULE_implicitCallStmt_InStmt = 116
    RULE_iCS_S_VariableOrProcedureCall = 117
    RULE_iCS_S_ProcedureOrArrayCall = 118
    RULE_iCS_S_MembersCall = 119
    RULE_iCS_S_MemberCall = 120
    RULE_iCS_S_DictionaryCall = 121
    RULE_argsCall = 122
    RULE_argCall = 123
    RULE_dictionaryCallStmt = 124
    RULE_argList = 125
    RULE_arg = 126
    RULE_argDefaultValue = 127
    RULE_subscripts = 128
    RULE_subscript_ = 129
    RULE_ambiguousIdentifier = 130
    RULE_asTypeClause = 131
    RULE_baseType = 132
    RULE_certainIdentifier = 133
    RULE_comparisonOperator = 134
    RULE_complexType = 135
    RULE_fieldLength = 136
    RULE_letterrange = 137
    RULE_lineLabel = 138
    RULE_literal = 139
    RULE_type_ = 140
    RULE_typeHint = 141
    RULE_visibility = 142
    RULE_ambiguousKeyword = 143
    RULE_remComment = 144
    RULE_comment = 145
    RULE_endOfLine = 146
    RULE_endOfStatement = 147

    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", "lineNumber", "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.13.1")
        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 = 296
            self.module()
            self.state = 297
            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 = 300
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.state = 299
                self.match(vbaParser.WS)


            self.state = 305
            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 = 302
                    self.endOfLine() 
                self.state = 307
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

            self.state = 315
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==178:
                self.state = 308
                self.moduleHeader()
                self.state = 312
                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 = 309
                        self.endOfLine() 
                    self.state = 314
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,2,self._ctx)



            self.state = 318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==17:
                self.state = 317
                self.moduleConfig()


            self.state = 323
            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 = 320
                    self.endOfLine() 
                self.state = 325
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)

            self.state = 327
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==13:
                self.state = 326
                self.moduleAttributes()


            self.state = 332
            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 = 329
                    self.endOfLine() 
                self.state = 334
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

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


            self.state = 341
            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 = 338
                    self.endOfLine() 
                self.state = 343
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 6773413840370532373) != 0) or _la==161 or _la==165:
                self.state = 344
                self.moduleBody()


            self.state = 350
            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 = 347
                    self.endOfLine() 
                self.state = 352
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

            self.state = 354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 353
                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 = 356
            self.match(vbaParser.VERSION)
            self.state = 357
            self.match(vbaParser.WS)
            self.state = 358
            self.match(vbaParser.DOUBLELITERAL)
            self.state = 359
            self.match(vbaParser.WS)
            self.state = 360
            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 = 362
            self.match(vbaParser.BEGIN)
            self.state = 366
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & 71) != 0):
                self.state = 363
                self.endOfLine()
                self.state = 368
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

            self.state = 374
            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 = 376
            self.ambiguousIdentifier()
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 377
                self.match(vbaParser.WS)


            self.state = 380
            self.match(vbaParser.EQ)
            self.state = 382
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 381
                self.match(vbaParser.WS)


            self.state = 384
            self.literal()
            self.state = 388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & 71) != 0):
                self.state = 385
                self.endOfLine()
                self.state = 390
                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 = 397 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 391
                self.attributeStmt()
                self.state = 393 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 392
                        self.endOfLine()

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

                self.state = 399 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==13):
                    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 = 401
            self.moduleDeclarationsElement()
            self.state = 411
            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 = 403 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 402
                            self.endOfLine()

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

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

            self.state = 417
            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 = 414
                    self.endOfLine() 
                self.state = 419
                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 = 428
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [123]:
                localctx = vbaParser.OptionBaseStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 420
                self.match(vbaParser.OPTION_BASE)
                self.state = 421
                self.match(vbaParser.WS)
                self.state = 422
                self.match(vbaParser.SHORTLITERAL)
                pass
            elif token in [125]:
                localctx = vbaParser.OptionCompareStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 423
                self.match(vbaParser.OPTION_COMPARE)
                self.state = 424
                self.match(vbaParser.WS)
                self.state = 425
                _la = self._input.LA(1)
                if not(_la==19 or _la==32 or _la==167):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [124]:
                localctx = vbaParser.OptionExplicitStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 426
                self.match(vbaParser.OPTION_EXPLICIT)
                pass
            elif token in [126]:
                localctx = vbaParser.OptionPrivateModuleStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 427
                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 deftypeStmt(self):
            return self.getTypedRuleContext(vbaParser.DeftypeStmtContext,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 = 441
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 430
                self.comment()
                pass

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

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

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

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

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

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

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

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

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 439
                self.deftypeStmt()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 440
                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 = 445
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [103]:
                self.enterOuterAlt(localctx, 1)
                self.state = 443
                self.macroConstStmt()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 2)
                self.state = 444
                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 = 447
            self.moduleBodyElement()
            self.state = 457
            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 = 449 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 448
                        self.endOfLine()
                        self.state = 451 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & 71) != 0)):
                            break

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

            self.state = 463
            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 = 460
                    self.endOfLine() 
                self.state = 465
                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 = 472
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 466
                self.functionStmt()
                pass

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

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

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

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

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 471
                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 = 474
            self.match(vbaParser.ATTRIBUTE)
            self.state = 475
            self.match(vbaParser.WS)
            self.state = 476
            self.implicitCallStmt_InStmt()
            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 477
                self.match(vbaParser.WS)


            self.state = 480
            self.match(vbaParser.EQ)
            self.state = 482
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 481
                self.match(vbaParser.WS)


            self.state = 484
            self.literal()
            self.state = 495
            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 = 486
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 485
                        self.match(vbaParser.WS)


                    self.state = 488
                    self.match(vbaParser.T__0)
                    self.state = 490
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 489
                        self.match(vbaParser.WS)


                    self.state = 492
                    self.literal() 
                self.state = 497
                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 = 498
            self.blockStmt()
            self.state = 504
            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 = 499
                    self.endOfStatement()
                    self.state = 500
                    self.blockStmt() 
                self.state = 506
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)

            self.state = 507
            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 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 lineNumber(self):
            return self.getTypedRuleContext(vbaParser.LineNumberContext,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 = 577
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 509
                self.lineLabel()
                pass

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

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

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

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

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

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

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

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

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

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 519
                self.doLoopStmt()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 520
                self.endStmt()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 521
                self.eraseStmt()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 522
                self.errorStmt()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 523
                self.exitStmt()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 524
                self.explicitCallStmt()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 525
                self.filecopyStmt()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 526
                self.forEachStmt()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 527
                self.forNextStmt()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 528
                self.getStmt()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 529
                self.goSubStmt()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 530
                self.goToStmt()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 531
                self.ifThenElseStmt()
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 532
                self.implementsStmt()
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 533
                self.inputStmt()
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 534
                self.killStmt()
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 535
                self.letStmt()
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 536
                self.lineInputStmt()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 537
                self.lineNumber()
                pass

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            elif la_ == 68:
                self.enterOuterAlt(localctx, 68)
                self.state = 576
                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 = 579
            self.match(vbaParser.APPACTIVATE)
            self.state = 580
            self.match(vbaParser.WS)
            self.state = 581
            self.valueStmt(0)
            self.state = 590
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 583
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 582
                    self.match(vbaParser.WS)


                self.state = 585
                self.match(vbaParser.T__0)
                self.state = 587
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 586
                    self.match(vbaParser.WS)


                self.state = 589
                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 = 592
            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 = 594
            self.match(vbaParser.CHDIR)
            self.state = 595
            self.match(vbaParser.WS)
            self.state = 596
            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 = 598
            self.match(vbaParser.CHDRIVE)
            self.state = 599
            self.match(vbaParser.WS)
            self.state = 600
            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 = 602
            self.match(vbaParser.CLOSE)
            self.state = 618
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 603
                self.match(vbaParser.WS)
                self.state = 604
                self.fileNumber()
                self.state = 615
                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 = 606
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 605
                            self.match(vbaParser.WS)


                        self.state = 608
                        self.match(vbaParser.T__0)
                        self.state = 610
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 609
                            self.match(vbaParser.WS)


                        self.state = 612
                        self.fileNumber() 
                    self.state = 617
                    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 = 623
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 620
                self.visibility()
                self.state = 621
                self.match(vbaParser.WS)


            self.state = 625
            self.match(vbaParser.CONST)
            self.state = 626
            self.match(vbaParser.WS)
            self.state = 627
            self.constSubStmt()
            self.state = 638
            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 = 629
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 628
                        self.match(vbaParser.WS)


                    self.state = 631
                    self.match(vbaParser.T__0)
                    self.state = 633
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 632
                        self.match(vbaParser.WS)


                    self.state = 635
                    self.constSubStmt() 
                self.state = 640
                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 = 641
            self.ambiguousIdentifier()
            self.state = 643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 642
                self.typeHint()


            self.state = 647
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.state = 645
                self.match(vbaParser.WS)
                self.state = 646
                self.asTypeClause()


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


            self.state = 652
            self.match(vbaParser.EQ)
            self.state = 654
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 653
                self.match(vbaParser.WS)


            self.state = 656
            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 = 658
            self.match(vbaParser.DATE)
            self.state = 660
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 659
                self.match(vbaParser.WS)


            self.state = 662
            self.match(vbaParser.EQ)
            self.state = 664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 663
                self.match(vbaParser.WS)


            self.state = 666
            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 = 671
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 668
                self.visibility()
                self.state = 669
                self.match(vbaParser.WS)


            self.state = 673
            self.match(vbaParser.DECLARE)
            self.state = 674
            self.match(vbaParser.WS)
            self.state = 677
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==136:
                self.state = 675
                self.match(vbaParser.PTRSAFE)
                self.state = 676
                self.match(vbaParser.WS)


            self.state = 684
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [77]:
                self.state = 679
                self.match(vbaParser.FUNCTION)
                self.state = 681
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                    self.state = 680
                    self.typeHint()


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

            self.state = 686
            self.match(vbaParser.WS)
            self.state = 687
            self.ambiguousIdentifier()
            self.state = 689
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 688
                self.typeHint()


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


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


                self.state = 704
                self.argList()


            self.state = 709
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.state = 707
                self.match(vbaParser.WS)
                self.state = 708
                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 = 711
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 140703128616960) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 712
            self.match(vbaParser.WS)
            self.state = 713
            self.letterrange()
            self.state = 724
            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 = 715
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 714
                        self.match(vbaParser.WS)


                    self.state = 717
                    self.match(vbaParser.T__0)
                    self.state = 719
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 718
                        self.match(vbaParser.WS)


                    self.state = 721
                    self.letterrange() 
                self.state = 726
                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 = 727
            self.match(vbaParser.DELETESETTING)
            self.state = 728
            self.match(vbaParser.WS)
            self.state = 729
            self.valueStmt(0)
            self.state = 731
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 730
                self.match(vbaParser.WS)


            self.state = 733
            self.match(vbaParser.T__0)
            self.state = 735
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 734
                self.match(vbaParser.WS)


            self.state = 737
            self.valueStmt(0)
            self.state = 746
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.state = 739
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 738
                    self.match(vbaParser.WS)


                self.state = 741
                self.match(vbaParser.T__0)
                self.state = 743
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 742
                    self.match(vbaParser.WS)


                self.state = 745
                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 = 775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 748
                self.match(vbaParser.DO)
                self.state = 749
                self.endOfStatement()
                self.state = 751
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
                if la_ == 1:
                    self.state = 750
                    self.block()


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

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


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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 766
                self.match(vbaParser.DO)
                self.state = 767
                self.endOfStatement()
                self.state = 768
                self.block()
                self.state = 769
                self.match(vbaParser.LOOP)
                self.state = 770
                self.match(vbaParser.WS)
                self.state = 771
                _la = self._input.LA(1)
                if not(_la==176 or _la==180):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 772
                self.match(vbaParser.WS)
                self.state = 773
                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 = 777
            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 = 782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 779
                self.visibility()
                self.state = 780
                self.match(vbaParser.WS)


            self.state = 784
            self.match(vbaParser.ENUM)
            self.state = 785
            self.match(vbaParser.WS)
            self.state = 786
            self.ambiguousIdentifier()
            self.state = 787
            self.endOfStatement()
            self.state = 791
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or _la==220:
                self.state = 788
                self.enumerationStmt_Constant()
                self.state = 793
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 794
            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 = 796
            self.ambiguousIdentifier()
            self.state = 805
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 797
                    self.match(vbaParser.WS)


                self.state = 800
                self.match(vbaParser.EQ)
                self.state = 802
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 801
                    self.match(vbaParser.WS)


                self.state = 804
                self.valueStmt(0)


            self.state = 807
            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 = 809
            self.match(vbaParser.ERASE)
            self.state = 810
            self.match(vbaParser.WS)
            self.state = 811
            self.valueStmt(0)
            self.state = 819
            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 = 812
                    self.match(vbaParser.T__0)
                    self.state = 814
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 813
                        self.match(vbaParser.WS)


                    self.state = 816
                    self.valueStmt(0) 
                self.state = 821
                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 = 822
            self.match(vbaParser.ERROR)
            self.state = 823
            self.match(vbaParser.WS)
            self.state = 824
            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 = 829
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 826
                self.visibility()
                self.state = 827
                self.match(vbaParser.WS)


            self.state = 831
            self.match(vbaParser.EVENT)
            self.state = 832
            self.match(vbaParser.WS)
            self.state = 833
            self.ambiguousIdentifier()
            self.state = 835
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 834
                self.match(vbaParser.WS)


            self.state = 837
            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 = 839
            _la = self._input.LA(1)
            if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 31) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class 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 = 841
            self.match(vbaParser.FILECOPY)
            self.state = 842
            self.match(vbaParser.WS)
            self.state = 843
            self.valueStmt(0)
            self.state = 845
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 844
                self.match(vbaParser.WS)


            self.state = 847
            self.match(vbaParser.T__0)
            self.state = 849
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 848
                self.match(vbaParser.WS)


            self.state = 851
            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 = 853
            self.match(vbaParser.FOR)
            self.state = 854
            self.match(vbaParser.WS)
            self.state = 855
            self.match(vbaParser.EACH)
            self.state = 856
            self.match(vbaParser.WS)
            self.state = 857
            self.ambiguousIdentifier()
            self.state = 859
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 858
                self.typeHint()


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


            self.state = 869
            self.match(vbaParser.NEXT)
            self.state = 872
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 870
                self.match(vbaParser.WS)
                self.state = 871
                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 = 874
            self.match(vbaParser.FOR)
            self.state = 875
            self.match(vbaParser.WS)
            self.state = 876
            self.ambiguousIdentifier()
            self.state = 878
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 877
                self.typeHint()


            self.state = 882
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
            if la_ == 1:
                self.state = 880
                self.match(vbaParser.WS)
                self.state = 881
                self.asTypeClause()


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


            self.state = 887
            self.match(vbaParser.EQ)
            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 888
                self.match(vbaParser.WS)


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


            self.state = 902
            self.endOfStatement()
            self.state = 904
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 903
                self.block()


            self.state = 906
            self.match(vbaParser.NEXT)
            self.state = 909
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.state = 907
                self.match(vbaParser.WS)
                self.state = 908
                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 = 914
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 911
                self.visibility()
                self.state = 912
                self.match(vbaParser.WS)


            self.state = 918
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 916
                self.match(vbaParser.STATIC)
                self.state = 917
                self.match(vbaParser.WS)


            self.state = 920
            self.match(vbaParser.FUNCTION)
            self.state = 922
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 921
                self.match(vbaParser.WS)


            self.state = 924
            self.ambiguousIdentifier()
            self.state = 926
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
            if la_ == 1:
                self.state = 925
                self.typeHint()


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


                self.state = 931
                self.argList()


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


                self.state = 937
                self.asTypeClause()


            self.state = 940
            self.endOfStatement()
            self.state = 942
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 941
                self.block()


            self.state = 944
            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 = 946
            self.match(vbaParser.GET)
            self.state = 947
            self.match(vbaParser.WS)
            self.state = 948
            self.fileNumber()
            self.state = 950
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 949
                self.match(vbaParser.WS)


            self.state = 952
            self.match(vbaParser.T__0)
            self.state = 954
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 953
                self.match(vbaParser.WS)


            self.state = 957
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & 135262277) != 0):
                self.state = 956
                self.valueStmt(0)


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


            self.state = 962
            self.match(vbaParser.T__0)
            self.state = 964
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 963
                self.match(vbaParser.WS)


            self.state = 966
            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 = 968
            self.match(vbaParser.GOSUB)
            self.state = 969
            self.match(vbaParser.WS)
            self.state = 970
            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 = 972
            self.match(vbaParser.GOTO)
            self.state = 973
            self.match(vbaParser.WS)
            self.state = 974
            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 = 1001
            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 = 976
                self.match(vbaParser.IF)
                self.state = 977
                self.match(vbaParser.WS)
                self.state = 978
                self.ifConditionStmt()
                self.state = 979
                self.match(vbaParser.WS)
                self.state = 980
                self.match(vbaParser.THEN)
                self.state = 981
                self.match(vbaParser.WS)
                self.state = 982
                self.blockStmt()
                self.state = 987
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                if la_ == 1:
                    self.state = 983
                    self.match(vbaParser.WS)
                    self.state = 984
                    self.match(vbaParser.ELSE)
                    self.state = 985
                    self.match(vbaParser.WS)
                    self.state = 986
                    self.blockStmt()


                pass

            elif la_ == 2:
                localctx = vbaParser.BlockIfThenElseContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 989
                self.ifBlockStmt()
                self.state = 993
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==53:
                    self.state = 990
                    self.ifElseIfBlockStmt()
                    self.state = 995
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 997
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==52:
                    self.state = 996
                    self.ifElseBlockStmt()


                self.state = 999
                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 = 1003
            self.match(vbaParser.IF)
            self.state = 1004
            self.match(vbaParser.WS)
            self.state = 1005
            self.ifConditionStmt()
            self.state = 1006
            self.match(vbaParser.WS)
            self.state = 1007
            self.match(vbaParser.THEN)
            self.state = 1008
            self.endOfStatement()
            self.state = 1010
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.state = 1009
                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 = 1012
            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 = 1014
            self.match(vbaParser.ELSEIF)
            self.state = 1015
            self.match(vbaParser.WS)
            self.state = 1016
            self.ifConditionStmt()
            self.state = 1017
            self.match(vbaParser.WS)
            self.state = 1018
            self.match(vbaParser.THEN)
            self.state = 1019
            self.endOfStatement()
            self.state = 1021
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 1020
                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 = 1023
            self.match(vbaParser.ELSE)
            self.state = 1024
            self.endOfStatement()
            self.state = 1026
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 1025
                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 = 1028
            self.match(vbaParser.IMPLEMENTS)
            self.state = 1029
            self.match(vbaParser.WS)
            self.state = 1030
            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 = 1032
            self.match(vbaParser.INPUT)
            self.state = 1033
            self.match(vbaParser.WS)
            self.state = 1034
            self.fileNumber()
            self.state = 1043 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1036
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1035
                        self.match(vbaParser.WS)


                    self.state = 1038
                    self.match(vbaParser.T__0)
                    self.state = 1040
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1039
                        self.match(vbaParser.WS)


                    self.state = 1042
                    self.valueStmt(0)

                else:
                    raise NoViableAltException(self)
                self.state = 1045 
                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 = 1047
            self.match(vbaParser.KILL)
            self.state = 1048
            self.match(vbaParser.WS)
            self.state = 1049
            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 = 1053
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.state = 1051
                self.match(vbaParser.LET)
                self.state = 1052
                self.match(vbaParser.WS)


            self.state = 1055
            self.implicitCallStmt_InStmt()
            self.state = 1057
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1056
                self.match(vbaParser.WS)


            self.state = 1059
            _la = self._input.LA(1)
            if not(((((_la - 189)) & ~0x3f) == 0 and ((1 << (_la - 189)) & 2177) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1061
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1060
                self.match(vbaParser.WS)


            self.state = 1063
            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 = 1065
            self.match(vbaParser.LINE_INPUT)
            self.state = 1066
            self.match(vbaParser.WS)
            self.state = 1067
            self.fileNumber()
            self.state = 1069
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1068
                self.match(vbaParser.WS)


            self.state = 1071
            self.match(vbaParser.T__0)
            self.state = 1073
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1072
                self.match(vbaParser.WS)


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

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

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

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

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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_lineNumber

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

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




    def lineNumber(self):

        localctx = vbaParser.LineNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_lineNumber)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1077
            _la = self._input.LA(1)
            if not(_la==208 or _la==209):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1079
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.state = 1078
                self.match(vbaParser.NEWLINE)


            self.state = 1082
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
            if la_ == 1:
                self.state = 1081
                self.match(vbaParser.COLON)


            self.state = 1085
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
            if la_ == 1:
                self.state = 1084
                self.match(vbaParser.NEWLINE)


            self.state = 1088
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.state = 1087
                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 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, 104, self.RULE_loadStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            self.match(vbaParser.LOAD)
            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 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, 106, self.RULE_lockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1094
            self.match(vbaParser.LOCK)
            self.state = 1095
            self.match(vbaParser.WS)
            self.state = 1096
            self.valueStmt(0)
            self.state = 1111
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
            if la_ == 1:
                self.state = 1098
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1097
                    self.match(vbaParser.WS)


                self.state = 1100
                self.match(vbaParser.T__0)
                self.state = 1102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1101
                    self.match(vbaParser.WS)


                self.state = 1104
                self.valueStmt(0)
                self.state = 1109
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
                if la_ == 1:
                    self.state = 1105
                    self.match(vbaParser.WS)
                    self.state = 1106
                    self.match(vbaParser.TO)
                    self.state = 1107
                    self.match(vbaParser.WS)
                    self.state = 1108
                    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, 108, self.RULE_lsetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1113
            self.match(vbaParser.LSET)
            self.state = 1114
            self.match(vbaParser.WS)
            self.state = 1115
            self.implicitCallStmt_InStmt()
            self.state = 1117
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1116
                self.match(vbaParser.WS)


            self.state = 1119
            self.match(vbaParser.EQ)
            self.state = 1121
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1120
                self.match(vbaParser.WS)


            self.state = 1123
            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, 110, self.RULE_macroConstStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1125
            self.match(vbaParser.MACRO_CONST)
            self.state = 1127
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1126
                self.match(vbaParser.WS)


            self.state = 1129
            self.ambiguousIdentifier()
            self.state = 1131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1130
                self.match(vbaParser.WS)


            self.state = 1133
            self.match(vbaParser.EQ)
            self.state = 1135
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1134
                self.match(vbaParser.WS)


            self.state = 1137
            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, 112, self.RULE_macroIfThenElseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            self.macroIfBlockStmt()
            self.state = 1143
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==105:
                self.state = 1140
                self.macroElseIfBlockStmt()
                self.state = 1145
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1147
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==106:
                self.state = 1146
                self.macroElseBlockStmt()


            self.state = 1149
            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, 114, self.RULE_macroIfBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1151
            self.match(vbaParser.MACRO_IF)
            self.state = 1153
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                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) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -15633680957441) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678719) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4243) != 0):
                self.state = 1162
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,140,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 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, 116, self.RULE_macroElseIfBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1167
            self.match(vbaParser.MACRO_ELSEIF)
            self.state = 1169
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1168
                self.match(vbaParser.WS)


            self.state = 1171
            self.ifConditionStmt()
            self.state = 1172
            self.match(vbaParser.WS)
            self.state = 1173
            self.match(vbaParser.THEN)
            self.state = 1174
            self.endOfStatement()
            self.state = 1180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -15633680957441) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678719) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4243) != 0):
                self.state = 1178
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,143,self._ctx)
                if la_ == 1:
                    self.state = 1175
                    self.moduleDeclarations()
                    pass

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

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


                self.state = 1182
                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, 118, self.RULE_macroElseBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1183
            self.match(vbaParser.MACRO_ELSE)
            self.state = 1184
            self.endOfStatement()
            self.state = 1190
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -15633680957441) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678719) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4243) != 0):
                self.state = 1188
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                if la_ == 1:
                    self.state = 1185
                    self.moduleDeclarations()
                    pass

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

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


                self.state = 1192
                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, 120, self.RULE_midStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1193
            self.match(vbaParser.MID)
            self.state = 1195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1194
                self.match(vbaParser.WS)


            self.state = 1197
            self.match(vbaParser.LPAREN)
            self.state = 1199
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.state = 1198
                self.match(vbaParser.WS)


            self.state = 1201
            self.argsCall()
            self.state = 1203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1202
                self.match(vbaParser.WS)


            self.state = 1205
            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, 122, self.RULE_mkdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1207
            self.match(vbaParser.MKDIR)
            self.state = 1208
            self.match(vbaParser.WS)
            self.state = 1209
            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, 124, self.RULE_nameStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1211
            self.match(vbaParser.NAME)
            self.state = 1212
            self.match(vbaParser.WS)
            self.state = 1213
            self.valueStmt(0)
            self.state = 1214
            self.match(vbaParser.WS)
            self.state = 1215
            self.match(vbaParser.AS)
            self.state = 1216
            self.match(vbaParser.WS)
            self.state = 1217
            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, 126, self.RULE_onErrorStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1219
            _la = self._input.LA(1)
            if not(_la==119 or _la==120):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1220
            self.match(vbaParser.WS)
            self.state = 1227
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 1221
                self.match(vbaParser.GOTO)
                self.state = 1222
                self.match(vbaParser.WS)
                self.state = 1223
                self.valueStmt(0)
                pass
            elif token in [147]:
                self.state = 1224
                self.match(vbaParser.RESUME)
                self.state = 1225
                self.match(vbaParser.WS)
                self.state = 1226
                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, 128, self.RULE_onGoToStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1229
            self.match(vbaParser.ON)
            self.state = 1230
            self.match(vbaParser.WS)
            self.state = 1231
            self.valueStmt(0)
            self.state = 1232
            self.match(vbaParser.WS)
            self.state = 1233
            self.match(vbaParser.GOTO)
            self.state = 1234
            self.match(vbaParser.WS)
            self.state = 1235
            self.valueStmt(0)
            self.state = 1246
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1237
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1236
                        self.match(vbaParser.WS)


                    self.state = 1239
                    self.match(vbaParser.T__0)
                    self.state = 1241
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1240
                        self.match(vbaParser.WS)


                    self.state = 1243
                    self.valueStmt(0) 
                self.state = 1248
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,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, 130, self.RULE_onGoSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1249
            self.match(vbaParser.ON)
            self.state = 1250
            self.match(vbaParser.WS)
            self.state = 1251
            self.valueStmt(0)
            self.state = 1252
            self.match(vbaParser.WS)
            self.state = 1253
            self.match(vbaParser.GOSUB)
            self.state = 1254
            self.match(vbaParser.WS)
            self.state = 1255
            self.valueStmt(0)
            self.state = 1266
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1257
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1256
                        self.match(vbaParser.WS)


                    self.state = 1259
                    self.match(vbaParser.T__0)
                    self.state = 1261
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1260
                        self.match(vbaParser.WS)


                    self.state = 1263
                    self.valueStmt(0) 
                self.state = 1268
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,156,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, 132, self.RULE_openStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1269
            self.match(vbaParser.OPEN)
            self.state = 1270
            self.match(vbaParser.WS)
            self.state = 1271
            self.valueStmt(0)
            self.state = 1272
            self.match(vbaParser.WS)
            self.state = 1273
            self.match(vbaParser.FOR)
            self.state = 1274
            self.match(vbaParser.WS)
            self.state = 1275
            _la = self._input.LA(1)
            if not(_la==15 or _la==19 or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 9011597301252097) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1280
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
            if la_ == 1:
                self.state = 1276
                self.match(vbaParser.WS)
                self.state = 1277
                self.match(vbaParser.ACCESS)
                self.state = 1278
                self.match(vbaParser.WS)
                self.state = 1279
                _la = self._input.LA(1)
                if not(((((_la - 142)) & ~0x3f) == 0 and ((1 << (_la - 142)) & 4398046511107) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
            if la_ == 1:
                self.state = 1282
                self.match(vbaParser.WS)
                self.state = 1283
                _la = self._input.LA(1)
                if not(((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 576460752303423495) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1286
            self.match(vbaParser.WS)
            self.state = 1287
            self.match(vbaParser.AS)
            self.state = 1288
            self.match(vbaParser.WS)
            self.state = 1289
            self.fileNumber()
            self.state = 1300
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
            if la_ == 1:
                self.state = 1290
                self.match(vbaParser.WS)
                self.state = 1291
                self.match(vbaParser.LEN)
                self.state = 1293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1292
                    self.match(vbaParser.WS)


                self.state = 1295
                self.match(vbaParser.EQ)
                self.state = 1297
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1296
                    self.match(vbaParser.WS)


                self.state = 1299
                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, 134, self.RULE_outputList)
        self._la = 0 # Token type
        try:
            self.state = 1335
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1302
                self.outputList_Expression()
                self.state = 1315
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,165,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1304
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1303
                            self.match(vbaParser.WS)


                        self.state = 1306
                        _la = self._input.LA(1)
                        if not(_la==1 or _la==2):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1308
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
                        if la_ == 1:
                            self.state = 1307
                            self.match(vbaParser.WS)


                        self.state = 1311
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                        if la_ == 1:
                            self.state = 1310
                            self.outputList_Expression()

                 
                    self.state = 1317
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,165,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1319
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & 135262277) != 0):
                    self.state = 1318
                    self.outputList_Expression()


                self.state = 1331 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1322
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1321
                            self.match(vbaParser.WS)


                        self.state = 1324
                        _la = self._input.LA(1)
                        if not(_la==1 or _la==2):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1326
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
                        if la_ == 1:
                            self.state = 1325
                            self.match(vbaParser.WS)


                        self.state = 1329
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                        if la_ == 1:
                            self.state = 1328
                            self.outputList_Expression()



                    else:
                        raise NoViableAltException(self)
                    self.state = 1333 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,170,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, 136, self.RULE_outputList_Expression)
        self._la = 0 # Token type
        try:
            self.state = 1354
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1337
                self.valueStmt(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1338
                _la = self._input.LA(1)
                if not(_la==160 or _la==166):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1352
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                if la_ == 1:
                    self.state = 1340
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1339
                        self.match(vbaParser.WS)


                    self.state = 1342
                    self.match(vbaParser.LPAREN)
                    self.state = 1344
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                    if la_ == 1:
                        self.state = 1343
                        self.match(vbaParser.WS)


                    self.state = 1346
                    self.argsCall()
                    self.state = 1348
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1347
                        self.match(vbaParser.WS)


                    self.state = 1350
                    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, 138, self.RULE_printStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1356
            self.match(vbaParser.PRINT)
            self.state = 1357
            self.match(vbaParser.WS)
            self.state = 1358
            self.fileNumber()
            self.state = 1360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1359
                self.match(vbaParser.WS)


            self.state = 1362
            self.match(vbaParser.T__0)
            self.state = 1367
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.state = 1364
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
                if la_ == 1:
                    self.state = 1363
                    self.match(vbaParser.WS)


                self.state = 1366
                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, 140, self.RULE_propertyGetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1372
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1369
                self.visibility()
                self.state = 1370
                self.match(vbaParser.WS)


            self.state = 1376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1374
                self.match(vbaParser.STATIC)
                self.state = 1375
                self.match(vbaParser.WS)


            self.state = 1378
            self.match(vbaParser.PROPERTY_GET)
            self.state = 1379
            self.match(vbaParser.WS)
            self.state = 1380
            self.ambiguousIdentifier()
            self.state = 1382
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.state = 1381
                self.typeHint()


            self.state = 1388
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
            if la_ == 1:
                self.state = 1385
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1384
                    self.match(vbaParser.WS)


                self.state = 1387
                self.argList()


            self.state = 1392
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
            if la_ == 1:
                self.state = 1390
                self.match(vbaParser.WS)
                self.state = 1391
                self.asTypeClause()


            self.state = 1394
            self.endOfStatement()
            self.state = 1396
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 1395
                self.block()


            self.state = 1398
            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, 142, self.RULE_propertySetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1400
                self.visibility()
                self.state = 1401
                self.match(vbaParser.WS)


            self.state = 1407
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1405
                self.match(vbaParser.STATIC)
                self.state = 1406
                self.match(vbaParser.WS)


            self.state = 1409
            self.match(vbaParser.PROPERTY_SET)
            self.state = 1410
            self.match(vbaParser.WS)
            self.state = 1411
            self.ambiguousIdentifier()
            self.state = 1416
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.state = 1413
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1412
                    self.match(vbaParser.WS)


                self.state = 1415
                self.argList()


            self.state = 1418
            self.endOfStatement()
            self.state = 1420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 1419
                self.block()


            self.state = 1422
            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, 144, self.RULE_propertyLetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1427
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1424
                self.visibility()
                self.state = 1425
                self.match(vbaParser.WS)


            self.state = 1431
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1429
                self.match(vbaParser.STATIC)
                self.state = 1430
                self.match(vbaParser.WS)


            self.state = 1433
            self.match(vbaParser.PROPERTY_LET)
            self.state = 1434
            self.match(vbaParser.WS)
            self.state = 1435
            self.ambiguousIdentifier()
            self.state = 1440
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1437
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1436
                    self.match(vbaParser.WS)


                self.state = 1439
                self.argList()


            self.state = 1442
            self.endOfStatement()
            self.state = 1444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 1443
                self.block()


            self.state = 1446
            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, 146, self.RULE_putStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1448
            self.match(vbaParser.PUT)
            self.state = 1449
            self.match(vbaParser.WS)
            self.state = 1450
            self.fileNumber()
            self.state = 1452
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1451
                self.match(vbaParser.WS)


            self.state = 1454
            self.match(vbaParser.T__0)
            self.state = 1456
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1455
                self.match(vbaParser.WS)


            self.state = 1459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & 135262277) != 0):
                self.state = 1458
                self.valueStmt(0)


            self.state = 1462
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1461
                self.match(vbaParser.WS)


            self.state = 1464
            self.match(vbaParser.T__0)
            self.state = 1466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1465
                self.match(vbaParser.WS)


            self.state = 1468
            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, 148, self.RULE_raiseEventStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1470
            self.match(vbaParser.RAISEEVENT)
            self.state = 1471
            self.match(vbaParser.WS)
            self.state = 1472
            self.ambiguousIdentifier()
            self.state = 1487
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.state = 1474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1473
                    self.match(vbaParser.WS)


                self.state = 1476
                self.match(vbaParser.LPAREN)
                self.state = 1478
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
                if la_ == 1:
                    self.state = 1477
                    self.match(vbaParser.WS)


                self.state = 1484
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                if la_ == 1:
                    self.state = 1480
                    self.argsCall()
                    self.state = 1482
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1481
                        self.match(vbaParser.WS)




                self.state = 1486
                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, 150, self.RULE_randomizeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1489
            self.match(vbaParser.RANDOMIZE)
            self.state = 1492
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
            if la_ == 1:
                self.state = 1490
                self.match(vbaParser.WS)
                self.state = 1491
                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, 152, self.RULE_redimStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1494
            self.match(vbaParser.REDIM)
            self.state = 1495
            self.match(vbaParser.WS)
            self.state = 1498
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
            if la_ == 1:
                self.state = 1496
                self.match(vbaParser.PRESERVE)
                self.state = 1497
                self.match(vbaParser.WS)


            self.state = 1500
            self.redimSubStmt()
            self.state = 1511
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,211,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1502
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1501
                        self.match(vbaParser.WS)


                    self.state = 1504
                    self.match(vbaParser.T__0)
                    self.state = 1506
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1505
                        self.match(vbaParser.WS)


                    self.state = 1508
                    self.redimSubStmt() 
                self.state = 1513
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,211,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, 154, self.RULE_redimSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1514
            self.implicitCallStmt_InStmt()
            self.state = 1516
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1515
                self.match(vbaParser.WS)


            self.state = 1518
            self.match(vbaParser.LPAREN)
            self.state = 1520
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1519
                self.match(vbaParser.WS)


            self.state = 1522
            self.subscripts()
            self.state = 1524
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1523
                self.match(vbaParser.WS)


            self.state = 1526
            self.match(vbaParser.RPAREN)
            self.state = 1529
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,215,self._ctx)
            if la_ == 1:
                self.state = 1527
                self.match(vbaParser.WS)
                self.state = 1528
                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, 156, self.RULE_resetStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            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, 158, self.RULE_resumeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1533
            self.match(vbaParser.RESUME)
            self.state = 1539
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
            if la_ == 1:
                self.state = 1534
                self.match(vbaParser.WS)
                self.state = 1537
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                if la_ == 1:
                    self.state = 1535
                    self.match(vbaParser.NEXT)
                    pass

                elif la_ == 2:
                    self.state = 1536
                    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, 160, self.RULE_returnStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1541
            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, 162, self.RULE_rmdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1543
            self.match(vbaParser.RMDIR)
            self.state = 1544
            self.match(vbaParser.WS)
            self.state = 1545
            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, 164, self.RULE_rsetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1547
            self.match(vbaParser.RSET)
            self.state = 1548
            self.match(vbaParser.WS)
            self.state = 1549
            self.implicitCallStmt_InStmt()
            self.state = 1551
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1550
                self.match(vbaParser.WS)


            self.state = 1553
            self.match(vbaParser.EQ)
            self.state = 1555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1554
                self.match(vbaParser.WS)


            self.state = 1557
            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, 166, self.RULE_savepictureStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            self.match(vbaParser.SAVEPICTURE)
            self.state = 1560
            self.match(vbaParser.WS)
            self.state = 1561
            self.valueStmt(0)
            self.state = 1563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1562
                self.match(vbaParser.WS)


            self.state = 1565
            self.match(vbaParser.T__0)
            self.state = 1567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1566
                self.match(vbaParser.WS)


            self.state = 1569
            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, 168, self.RULE_saveSettingStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1571
            self.match(vbaParser.SAVESETTING)
            self.state = 1572
            self.match(vbaParser.WS)
            self.state = 1573
            self.valueStmt(0)
            self.state = 1575
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                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==219:
                self.state = 1578
                self.match(vbaParser.WS)


            self.state = 1581
            self.valueStmt(0)
            self.state = 1583
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1582
                self.match(vbaParser.WS)


            self.state = 1585
            self.match(vbaParser.T__0)
            self.state = 1587
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1586
                self.match(vbaParser.WS)


            self.state = 1589
            self.valueStmt(0)
            self.state = 1591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1590
                self.match(vbaParser.WS)


            self.state = 1593
            self.match(vbaParser.T__0)
            self.state = 1595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1594
                self.match(vbaParser.WS)


            self.state = 1597
            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, 170, self.RULE_seekStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1599
            self.match(vbaParser.SEEK)
            self.state = 1600
            self.match(vbaParser.WS)
            self.state = 1601
            self.fileNumber()
            self.state = 1603
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1602
                self.match(vbaParser.WS)


            self.state = 1605
            self.match(vbaParser.T__0)
            self.state = 1607
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1606
                self.match(vbaParser.WS)


            self.state = 1609
            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, 172, self.RULE_selectCaseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1611
            self.match(vbaParser.SELECT)
            self.state = 1612
            self.match(vbaParser.WS)
            self.state = 1613
            self.match(vbaParser.CASE)
            self.state = 1614
            self.match(vbaParser.WS)
            self.state = 1615
            self.valueStmt(0)
            self.state = 1616
            self.endOfStatement()
            self.state = 1620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==25:
                self.state = 1617
                self.sC_Case()
                self.state = 1622
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1623
            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, 174, self.RULE_sC_Selection)
        self._la = 0 # Token type
        try:
            self.state = 1642
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondIsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1625
                self.match(vbaParser.IS)
                self.state = 1627
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1626
                    self.match(vbaParser.WS)


                self.state = 1629
                self.comparisonOperator()
                self.state = 1631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1630
                    self.match(vbaParser.WS)


                self.state = 1633
                self.valueStmt(0)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondToContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1635
                self.valueStmt(0)
                self.state = 1636
                self.match(vbaParser.WS)
                self.state = 1637
                self.match(vbaParser.TO)
                self.state = 1638
                self.match(vbaParser.WS)
                self.state = 1639
                self.valueStmt(0)
                pass

            elif la_ == 3:
                localctx = vbaParser.CaseCondValueContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1641
                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, 176, self.RULE_sC_Case)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1644
            self.match(vbaParser.CASE)
            self.state = 1645
            self.match(vbaParser.WS)
            self.state = 1646
            self.sC_Cond()
            self.state = 1647
            self.endOfStatement()
            self.state = 1649
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                self.state = 1648
                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, 178, self.RULE_sC_Cond)
        self._la = 0 # Token type
        try:
            self.state = 1666
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondElseContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1651
                self.match(vbaParser.ELSE)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondSelectionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1652
                self.sC_Selection()
                self.state = 1663
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,237,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1654
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1653
                            self.match(vbaParser.WS)


                        self.state = 1656
                        self.match(vbaParser.T__0)
                        self.state = 1658
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1657
                            self.match(vbaParser.WS)


                        self.state = 1660
                        self.sC_Selection() 
                    self.state = 1665
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,237,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, 180, self.RULE_sendkeysStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1668
            self.match(vbaParser.SENDKEYS)
            self.state = 1669
            self.match(vbaParser.WS)
            self.state = 1670
            self.valueStmt(0)
            self.state = 1679
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
            if la_ == 1:
                self.state = 1672
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1671
                    self.match(vbaParser.WS)


                self.state = 1674
                self.match(vbaParser.T__0)
                self.state = 1676
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1675
                    self.match(vbaParser.WS)


                self.state = 1678
                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, 182, self.RULE_setattrStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1681
            self.match(vbaParser.SETATTR)
            self.state = 1682
            self.match(vbaParser.WS)
            self.state = 1683
            self.valueStmt(0)
            self.state = 1685
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1684
                self.match(vbaParser.WS)


            self.state = 1687
            self.match(vbaParser.T__0)
            self.state = 1689
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1688
                self.match(vbaParser.WS)


            self.state = 1691
            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, 184, self.RULE_setStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1693
            self.match(vbaParser.SET)
            self.state = 1694
            self.match(vbaParser.WS)
            self.state = 1695
            self.implicitCallStmt_InStmt()
            self.state = 1697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1696
                self.match(vbaParser.WS)


            self.state = 1699
            self.match(vbaParser.EQ)
            self.state = 1701
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1700
                self.match(vbaParser.WS)


            self.state = 1703
            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, 186, self.RULE_stopStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1705
            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, 188, self.RULE_subStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1710
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1707
                self.visibility()
                self.state = 1708
                self.match(vbaParser.WS)


            self.state = 1714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1712
                self.match(vbaParser.STATIC)
                self.state = 1713
                self.match(vbaParser.WS)


            self.state = 1716
            self.match(vbaParser.SUB)
            self.state = 1718
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1717
                self.match(vbaParser.WS)


            self.state = 1720
            self.ambiguousIdentifier()
            self.state = 1725
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
            if la_ == 1:
                self.state = 1722
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1721
                    self.match(vbaParser.WS)


                self.state = 1724
                self.argList()


            self.state = 1727
            self.endOfStatement()
            self.state = 1729
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 1728
                self.block()


            self.state = 1731
            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, 190, self.RULE_timeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1733
            self.match(vbaParser.TIME)
            self.state = 1735
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1734
                self.match(vbaParser.WS)


            self.state = 1737
            self.match(vbaParser.EQ)
            self.state = 1739
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1738
                self.match(vbaParser.WS)


            self.state = 1741
            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, 192, self.RULE_typeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1746
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1743
                self.visibility()
                self.state = 1744
                self.match(vbaParser.WS)


            self.state = 1748
            self.match(vbaParser.TYPE)
            self.state = 1749
            self.match(vbaParser.WS)
            self.state = 1750
            self.ambiguousIdentifier()
            self.state = 1751
            self.endOfStatement()
            self.state = 1755
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or _la==220:
                self.state = 1752
                self.typeStmt_Element()
                self.state = 1757
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1758
            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, 194, self.RULE_typeStmt_Element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1760
            self.ambiguousIdentifier()
            self.state = 1775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,260,self._ctx)
            if la_ == 1:
                self.state = 1762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1761
                    self.match(vbaParser.WS)


                self.state = 1764
                self.match(vbaParser.LPAREN)
                self.state = 1769
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
                if la_ == 1:
                    self.state = 1766
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1765
                        self.match(vbaParser.WS)


                    self.state = 1768
                    self.subscripts()


                self.state = 1772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1771
                    self.match(vbaParser.WS)


                self.state = 1774
                self.match(vbaParser.RPAREN)


            self.state = 1779
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
            if la_ == 1:
                self.state = 1777
                self.match(vbaParser.WS)
                self.state = 1778
                self.asTypeClause()


            self.state = 1781
            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, 196, self.RULE_typeOfStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1783
            self.match(vbaParser.TYPEOF)
            self.state = 1784
            self.match(vbaParser.WS)
            self.state = 1785
            self.valueStmt(0)
            self.state = 1790
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.state = 1786
                self.match(vbaParser.WS)
                self.state = 1787
                self.match(vbaParser.IS)
                self.state = 1788
                self.match(vbaParser.WS)
                self.state = 1789
                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, 198, self.RULE_unloadStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1792
            self.match(vbaParser.UNLOAD)
            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 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, 200, self.RULE_unlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1796
            self.match(vbaParser.UNLOCK)
            self.state = 1797
            self.match(vbaParser.WS)
            self.state = 1798
            self.fileNumber()
            self.state = 1813
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,266,self._ctx)
            if la_ == 1:
                self.state = 1800
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1799
                    self.match(vbaParser.WS)


                self.state = 1802
                self.match(vbaParser.T__0)
                self.state = 1804
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1803
                    self.match(vbaParser.WS)


                self.state = 1806
                self.valueStmt(0)
                self.state = 1811
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,265,self._ctx)
                if la_ == 1:
                    self.state = 1807
                    self.match(vbaParser.WS)
                    self.state = 1808
                    self.match(vbaParser.TO)
                    self.state = 1809
                    self.match(vbaParser.WS)
                    self.state = 1810
                    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 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 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 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 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 VsRelationalContext(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 LIKE(self):
            return self.getToken(vbaParser.LIKE, 0)
        def GEQ(self):
            return self.getToken(vbaParser.GEQ, 0)
        def LEQ(self):
            return self.getToken(vbaParser.LEQ, 0)
        def GT(self):
            return self.getToken(vbaParser.GT, 0)
        def LT(self):
            return self.getToken(vbaParser.LT, 0)
        def NEQ(self):
            return self.getToken(vbaParser.NEQ, 0)
        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, "enterVsRelational" ):
                listener.enterVsRelational(self)

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


    class VsAddMinusContext(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 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, "enterVsAddMinus" ):
                listener.enterVsAddMinus(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVsAddMinus" ):
                listener.exitVsAddMinus(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 VsDivMultContext(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 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, "enterVsDivMult" ):
                listener.enterVsDivMult(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVsDivMult" ):
                listener.exitVsDivMult(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 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 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 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 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 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 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 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 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 = 202
        self.enterRecursionRule(localctx, 202, self.RULE_valueStmt, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1875
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
            if la_ == 1:
                localctx = vbaParser.VsLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1816
                self.literal()
                pass

            elif la_ == 2:
                localctx = vbaParser.VsICSContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1817
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 3:
                localctx = vbaParser.VsStructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1818
                self.match(vbaParser.LPAREN)
                self.state = 1820
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1819
                    self.match(vbaParser.WS)


                self.state = 1822
                self.valueStmt(0)
                self.state = 1833
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==1 or _la==219:
                    self.state = 1824
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1823
                        self.match(vbaParser.WS)


                    self.state = 1826
                    self.match(vbaParser.T__0)
                    self.state = 1828
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1827
                        self.match(vbaParser.WS)


                    self.state = 1830
                    self.valueStmt(0)
                    self.state = 1835
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1836
                self.match(vbaParser.RPAREN)
                pass

            elif la_ == 4:
                localctx = vbaParser.VsNewContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1838
                self.match(vbaParser.NEW)
                self.state = 1840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1839
                    self.match(vbaParser.WS)


                self.state = 1842
                self.valueStmt(19)
                pass

            elif la_ == 5:
                localctx = vbaParser.VsTypeOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1843
                self.typeOfStmt()
                pass

            elif la_ == 6:
                localctx = vbaParser.VsMidContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1844
                self.midStmt()
                pass

            elif la_ == 7:
                localctx = vbaParser.VsAddressOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1845
                self.match(vbaParser.ADDRESSOF)
                self.state = 1847
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1846
                    self.match(vbaParser.WS)


                self.state = 1849
                self.valueStmt(16)
                pass

            elif la_ == 8:
                localctx = vbaParser.VsAssignContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1850
                self.implicitCallStmt_InStmt()
                self.state = 1852
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1851
                    self.match(vbaParser.WS)


                self.state = 1854
                self.match(vbaParser.ASSIGN)
                self.state = 1856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1855
                    self.match(vbaParser.WS)


                self.state = 1858
                self.valueStmt(15)
                pass

            elif la_ == 9:
                localctx = vbaParser.VsNegationContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1860
                self.match(vbaParser.MINUS)
                self.state = 1862
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1861
                    self.match(vbaParser.WS)


                self.state = 1864
                self.valueStmt(13)
                pass

            elif la_ == 10:
                localctx = vbaParser.VsPlusContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1865
                self.match(vbaParser.PLUS)
                self.state = 1867
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1866
                    self.match(vbaParser.WS)


                self.state = 1869
                self.valueStmt(12)
                pass

            elif la_ == 11:
                localctx = vbaParser.VsNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1870
                self.match(vbaParser.NOT)
                self.state = 1872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1871
                    self.match(vbaParser.WS)


                self.state = 1874
                self.valueStmt(6)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1978
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,302,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 = 1976
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
                    if la_ == 1:
                        localctx = vbaParser.VsPowContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1877
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1879
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1878
                            self.match(vbaParser.WS)


                        self.state = 1881
                        self.match(vbaParser.POW)
                        self.state = 1883
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1882
                            self.match(vbaParser.WS)


                        self.state = 1885
                        self.valueStmt(15)
                        pass

                    elif la_ == 2:
                        localctx = vbaParser.VsDivMultContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1886
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1888
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1887
                            self.match(vbaParser.WS)


                        self.state = 1890
                        _la = self._input.LA(1)
                        if not(_la==188 or _la==197):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1892
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1891
                            self.match(vbaParser.WS)


                        self.state = 1894
                        self.valueStmt(12)
                        pass

                    elif la_ == 3:
                        localctx = vbaParser.VsModContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1895
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1897
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1896
                            self.match(vbaParser.WS)


                        self.state = 1899
                        self.match(vbaParser.MOD)
                        self.state = 1901
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1900
                            self.match(vbaParser.WS)


                        self.state = 1903
                        self.valueStmt(11)
                        pass

                    elif la_ == 4:
                        localctx = vbaParser.VsAddMinusContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1904
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1906
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1905
                            self.match(vbaParser.WS)


                        self.state = 1908
                        _la = self._input.LA(1)
                        if not(_la==195 or _la==199):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1910
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1909
                            self.match(vbaParser.WS)


                        self.state = 1912
                        self.valueStmt(10)
                        pass

                    elif la_ == 5:
                        localctx = vbaParser.VsAmpContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1913
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1915
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1914
                            self.match(vbaParser.WS)


                        self.state = 1917
                        self.match(vbaParser.AMPERSAND)
                        self.state = 1919
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1918
                            self.match(vbaParser.WS)


                        self.state = 1921
                        self.valueStmt(9)
                        pass

                    elif la_ == 6:
                        localctx = vbaParser.VsRelationalContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1922
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1924
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1923
                            self.match(vbaParser.WS)


                        self.state = 1926
                        _la = self._input.LA(1)
                        if not(_la==87 or _la==97 or ((((_la - 189)) & ~0x3f) == 0 and ((1 << (_la - 189)) & 559) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1928
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1927
                            self.match(vbaParser.WS)


                        self.state = 1930
                        self.valueStmt(8)
                        pass

                    elif la_ == 7:
                        localctx = vbaParser.VsAndContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1931
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1933
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1932
                            self.match(vbaParser.WS)


                        self.state = 1935
                        self.match(vbaParser.AND)
                        self.state = 1937
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1936
                            self.match(vbaParser.WS)


                        self.state = 1939
                        self.valueStmt(6)
                        pass

                    elif la_ == 8:
                        localctx = vbaParser.VsOrContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1940
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1942
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1941
                            self.match(vbaParser.WS)


                        self.state = 1944
                        self.match(vbaParser.OR)
                        self.state = 1946
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1945
                            self.match(vbaParser.WS)


                        self.state = 1948
                        self.valueStmt(5)
                        pass

                    elif la_ == 9:
                        localctx = vbaParser.VsXorContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1949
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1951
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1950
                            self.match(vbaParser.WS)


                        self.state = 1953
                        self.match(vbaParser.XOR)
                        self.state = 1955
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1954
                            self.match(vbaParser.WS)


                        self.state = 1957
                        self.valueStmt(4)
                        pass

                    elif la_ == 10:
                        localctx = vbaParser.VsEqvContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1958
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1960
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1959
                            self.match(vbaParser.WS)


                        self.state = 1962
                        self.match(vbaParser.EQV)
                        self.state = 1964
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1963
                            self.match(vbaParser.WS)


                        self.state = 1966
                        self.valueStmt(3)
                        pass

                    elif la_ == 11:
                        localctx = vbaParser.VsImpContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1967
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1969
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1968
                            self.match(vbaParser.WS)


                        self.state = 1971
                        self.match(vbaParser.IMP)
                        self.state = 1973
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1972
                            self.match(vbaParser.WS)


                        self.state = 1975
                        self.valueStmt(2)
                        pass

             
                self.state = 1980
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,302,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, 204, self.RULE_variableStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1984
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48]:
                self.state = 1981
                self.match(vbaParser.DIM)
                pass
            elif token in [161]:
                self.state = 1982
                self.match(vbaParser.STATIC)
                pass
            elif token in [75, 79, 132, 137]:
                self.state = 1983
                self.visibility()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1986
            self.match(vbaParser.WS)
            self.state = 1989
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
            if la_ == 1:
                self.state = 1987
                self.match(vbaParser.WITHEVENTS)
                self.state = 1988
                self.match(vbaParser.WS)


            self.state = 1991
            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, 206, self.RULE_variableListStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1993
            self.variableSubStmt()
            self.state = 2004
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,307,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1995
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1994
                        self.match(vbaParser.WS)


                    self.state = 1997
                    self.match(vbaParser.T__0)
                    self.state = 1999
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1998
                        self.match(vbaParser.WS)


                    self.state = 2001
                    self.variableSubStmt() 
                self.state = 2006
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,307,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, 208, self.RULE_variableSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2007
            self.ambiguousIdentifier()
            self.state = 2025
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
            if la_ == 1:
                self.state = 2009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2008
                    self.match(vbaParser.WS)


                self.state = 2011
                self.match(vbaParser.LPAREN)
                self.state = 2013
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2012
                    self.match(vbaParser.WS)


                self.state = 2019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & 135262277) != 0):
                    self.state = 2015
                    self.subscripts()
                    self.state = 2017
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2016
                        self.match(vbaParser.WS)




                self.state = 2021
                self.match(vbaParser.RPAREN)
                self.state = 2023
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
                if la_ == 1:
                    self.state = 2022
                    self.match(vbaParser.WS)




            self.state = 2028
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,314,self._ctx)
            if la_ == 1:
                self.state = 2027
                self.typeHint()


            self.state = 2032
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,315,self._ctx)
            if la_ == 1:
                self.state = 2030
                self.match(vbaParser.WS)
                self.state = 2031
                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, 210, self.RULE_whileWendStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2034
            self.match(vbaParser.WHILE)
            self.state = 2035
            self.match(vbaParser.WS)
            self.state = 2036
            self.valueStmt(0)
            self.state = 2037
            self.endOfStatement()
            self.state = 2039
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,316,self._ctx)
            if la_ == 1:
                self.state = 2038
                self.block()


            self.state = 2041
            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, 212, self.RULE_widthStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2043
            self.match(vbaParser.WIDTH)
            self.state = 2044
            self.match(vbaParser.WS)
            self.state = 2045
            self.fileNumber()
            self.state = 2047
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2046
                self.match(vbaParser.WS)


            self.state = 2049
            self.match(vbaParser.T__0)
            self.state = 2051
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2050
                self.match(vbaParser.WS)


            self.state = 2053
            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, 214, self.RULE_withStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2055
            self.match(vbaParser.WITH)
            self.state = 2056
            self.match(vbaParser.WS)
            self.state = 2061
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
            if la_ == 1:
                self.state = 2057
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 2:
                self.state = 2058
                self.match(vbaParser.NEW)
                self.state = 2059
                self.match(vbaParser.WS)
                self.state = 2060
                self.type_()
                pass


            self.state = 2063
            self.endOfStatement()
            self.state = 2065
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8646926918232309761) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & 4115) != 0):
                self.state = 2064
                self.block()


            self.state = 2067
            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, 216, self.RULE_writeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2069
            self.match(vbaParser.WRITE)
            self.state = 2070
            self.match(vbaParser.WS)
            self.state = 2071
            self.fileNumber()
            self.state = 2073
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2072
                self.match(vbaParser.WS)


            self.state = 2075
            self.match(vbaParser.T__0)
            self.state = 2080
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
            if la_ == 1:
                self.state = 2077
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,322,self._ctx)
                if la_ == 1:
                    self.state = 2076
                    self.match(vbaParser.WS)


                self.state = 2079
                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, 218, self.RULE_fileNumber)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2083
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==3:
                self.state = 2082
                self.match(vbaParser.T__2)


            self.state = 2085
            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, 220, self.RULE_explicitCallStmt)
        try:
            self.state = 2089
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2087
                self.eCS_ProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2088
                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, 222, self.RULE_eCS_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2091
            self.match(vbaParser.CALL)
            self.state = 2092
            self.match(vbaParser.WS)
            self.state = 2093
            self.ambiguousIdentifier()
            self.state = 2095
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
            if la_ == 1:
                self.state = 2094
                self.typeHint()


            self.state = 2110
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
            if la_ == 1:
                self.state = 2098
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2097
                    self.match(vbaParser.WS)


                self.state = 2100
                self.match(vbaParser.LPAREN)
                self.state = 2102
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,328,self._ctx)
                if la_ == 1:
                    self.state = 2101
                    self.match(vbaParser.WS)


                self.state = 2104
                self.argsCall()
                self.state = 2106
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2105
                    self.match(vbaParser.WS)


                self.state = 2108
                self.match(vbaParser.RPAREN)


            self.state = 2121
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,332,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2113
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2112
                        self.match(vbaParser.WS)


                    self.state = 2115
                    self.match(vbaParser.LPAREN)
                    self.state = 2116
                    self.subscripts()
                    self.state = 2117
                    self.match(vbaParser.RPAREN) 
                self.state = 2123
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,332,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, 224, self.RULE_eCS_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2124
            self.match(vbaParser.CALL)
            self.state = 2125
            self.match(vbaParser.WS)
            self.state = 2127
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,333,self._ctx)
            if la_ == 1:
                self.state = 2126
                self.implicitCallStmt_InStmt()


            self.state = 2129
            self.match(vbaParser.T__3)
            self.state = 2130
            self.ambiguousIdentifier()
            self.state = 2132
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,334,self._ctx)
            if la_ == 1:
                self.state = 2131
                self.typeHint()


            self.state = 2147
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                self.state = 2135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2134
                    self.match(vbaParser.WS)


                self.state = 2137
                self.match(vbaParser.LPAREN)
                self.state = 2139
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,336,self._ctx)
                if la_ == 1:
                    self.state = 2138
                    self.match(vbaParser.WS)


                self.state = 2141
                self.argsCall()
                self.state = 2143
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2142
                    self.match(vbaParser.WS)


                self.state = 2145
                self.match(vbaParser.RPAREN)


            self.state = 2158
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,340,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2150
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2149
                        self.match(vbaParser.WS)


                    self.state = 2152
                    self.match(vbaParser.LPAREN)
                    self.state = 2153
                    self.subscripts()
                    self.state = 2154
                    self.match(vbaParser.RPAREN) 
                self.state = 2160
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,340,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, 226, self.RULE_implicitCallStmt_InBlock)
        try:
            self.state = 2163
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2161
                self.iCS_B_MemberProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2162
                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, 228, self.RULE_iCS_B_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2166
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,342,self._ctx)
            if la_ == 1:
                self.state = 2165
                self.implicitCallStmt_InStmt()


            self.state = 2168
            self.match(vbaParser.T__3)
            self.state = 2169
            self.ambiguousIdentifier()
            self.state = 2171
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,343,self._ctx)
            if la_ == 1:
                self.state = 2170
                self.typeHint()


            self.state = 2175
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.state = 2173
                self.match(vbaParser.WS)
                self.state = 2174
                self.argsCall()


            self.state = 2178
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,345,self._ctx)
            if la_ == 1:
                self.state = 2177
                self.dictionaryCallStmt()


            self.state = 2189
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,347,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2181
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2180
                        self.match(vbaParser.WS)


                    self.state = 2183
                    self.match(vbaParser.LPAREN)
                    self.state = 2184
                    self.subscripts()
                    self.state = 2185
                    self.match(vbaParser.RPAREN) 
                self.state = 2191
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,347,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, 230, self.RULE_iCS_B_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2192
            self.certainIdentifier()
            self.state = 2195
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,348,self._ctx)
            if la_ == 1:
                self.state = 2193
                self.match(vbaParser.WS)
                self.state = 2194
                self.argsCall()


            self.state = 2206
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,350,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2198
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2197
                        self.match(vbaParser.WS)


                    self.state = 2200
                    self.match(vbaParser.LPAREN)
                    self.state = 2201
                    self.subscripts()
                    self.state = 2202
                    self.match(vbaParser.RPAREN) 
                self.state = 2208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,350,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, 232, self.RULE_implicitCallStmt_InStmt)
        try:
            self.state = 2213
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,351,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2209
                self.iCS_S_MembersCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2210
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2211
                self.iCS_S_ProcedureOrArrayCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2212
                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, 234, self.RULE_iCS_S_VariableOrProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2215
            self.ambiguousIdentifier()
            self.state = 2217
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,352,self._ctx)
            if la_ == 1:
                self.state = 2216
                self.typeHint()


            self.state = 2220
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,353,self._ctx)
            if la_ == 1:
                self.state = 2219
                self.dictionaryCallStmt()


            self.state = 2231
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,355,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2223
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2222
                        self.match(vbaParser.WS)


                    self.state = 2225
                    self.match(vbaParser.LPAREN)
                    self.state = 2226
                    self.subscripts()
                    self.state = 2227
                    self.match(vbaParser.RPAREN) 
                self.state = 2233
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,355,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, 236, self.RULE_iCS_S_ProcedureOrArrayCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2236
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,356,self._ctx)
            if la_ == 1:
                self.state = 2234
                self.ambiguousIdentifier()
                pass

            elif la_ == 2:
                self.state = 2235
                self.baseType()
                pass


            self.state = 2239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 2238
                self.typeHint()


            self.state = 2242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2241
                self.match(vbaParser.WS)


            self.state = 2244
            self.match(vbaParser.LPAREN)
            self.state = 2246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,359,self._ctx)
            if la_ == 1:
                self.state = 2245
                self.match(vbaParser.WS)


            self.state = 2252
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,361,self._ctx)
            if la_ == 1:
                self.state = 2248
                self.argsCall()
                self.state = 2250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2249
                    self.match(vbaParser.WS)




            self.state = 2254
            self.match(vbaParser.RPAREN)
            self.state = 2256
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,362,self._ctx)
            if la_ == 1:
                self.state = 2255
                self.dictionaryCallStmt()


            self.state = 2267
            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 = 2259
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2258
                        self.match(vbaParser.WS)


                    self.state = 2261
                    self.match(vbaParser.LPAREN)
                    self.state = 2262
                    self.subscripts()
                    self.state = 2263
                    self.match(vbaParser.RPAREN) 
                self.state = 2269
                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 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, 238, self.RULE_iCS_S_MembersCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2272
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,365,self._ctx)
            if la_ == 1:
                self.state = 2270
                self.iCS_S_VariableOrProcedureCall()

            elif la_ == 2:
                self.state = 2271
                self.iCS_S_ProcedureOrArrayCall()


            self.state = 2275 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2274
                    self.iCS_S_MemberCall()

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

            self.state = 2280
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,367,self._ctx)
            if la_ == 1:
                self.state = 2279
                self.dictionaryCallStmt()


            self.state = 2291
            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 = 2283
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2282
                        self.match(vbaParser.WS)


                    self.state = 2285
                    self.match(vbaParser.LPAREN)
                    self.state = 2286
                    self.subscripts()
                    self.state = 2287
                    self.match(vbaParser.RPAREN) 
                self.state = 2293
                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_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 LINE_CONTINUATION(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LINE_CONTINUATION)
            else:
                return self.getToken(vbaParser.LINE_CONTINUATION, i)

        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, 240, self.RULE_iCS_S_MemberCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 2294
                self.match(vbaParser.LINE_CONTINUATION)


            self.state = 2297
            _la = self._input.LA(1)
            if not(_la==4 or _la==5):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2299
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 2298
                self.match(vbaParser.LINE_CONTINUATION)


            self.state = 2303
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,372,self._ctx)
            if la_ == 1:
                self.state = 2301
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 2:
                self.state = 2302
                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, 242, self.RULE_iCS_S_DictionaryCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2305
            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, 244, self.RULE_argsCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2319
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,376,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2308
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906384) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 0) or ((((_la - 193)) & ~0x3f) == 0 and ((1 << (_la - 193)) & 135262789) != 0):
                        self.state = 2307
                        self.argCall()


                    self.state = 2311
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2310
                        self.match(vbaParser.WS)


                    self.state = 2313
                    _la = self._input.LA(1)
                    if not(_la==1 or _la==2):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2315
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
                    if la_ == 1:
                        self.state = 2314
                        self.match(vbaParser.WS)

             
                self.state = 2321
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,376,self._ctx)

            self.state = 2322
            self.argCall()
            self.state = 2335
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,380,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==219:
                        self.state = 2323
                        self.match(vbaParser.WS)


                    self.state = 2326
                    _la = self._input.LA(1)
                    if not(_la==1 or _la==2):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2328
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,378,self._ctx)
                    if la_ == 1:
                        self.state = 2327
                        self.match(vbaParser.WS)


                    self.state = 2331
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,379,self._ctx)
                    if la_ == 1:
                        self.state = 2330
                        self.argCall()

             
                self.state = 2337
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,380,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, 246, self.RULE_argCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2339
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,381,self._ctx)
            if la_ == 1:
                self.state = 2338
                self.match(vbaParser.LPAREN)


            self.state = 2343
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,382,self._ctx)
            if la_ == 1:
                self.state = 2341
                _la = self._input.LA(1)
                if not(_la==21 or _la==22 or _la==129):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2342
                self.match(vbaParser.WS)


            self.state = 2346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==202:
                self.state = 2345
                self.match(vbaParser.RPAREN)


            self.state = 2348
            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, 248, self.RULE_dictionaryCallStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2350
            self.match(vbaParser.T__4)
            self.state = 2351
            self.ambiguousIdentifier()
            self.state = 2353
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,384,self._ctx)
            if la_ == 1:
                self.state = 2352
                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, 250, self.RULE_argList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2355
            self.match(vbaParser.LPAREN)
            self.state = 2373
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,389,self._ctx)
            if la_ == 1:
                self.state = 2357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2356
                    self.match(vbaParser.WS)


                self.state = 2359
                self.arg()
                self.state = 2370
                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 = 2361
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2360
                            self.match(vbaParser.WS)


                        self.state = 2363
                        self.match(vbaParser.T__0)
                        self.state = 2365
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2364
                            self.match(vbaParser.WS)


                        self.state = 2367
                        self.arg() 
                    self.state = 2372
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,388,self._ctx)



            self.state = 2376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2375
                self.match(vbaParser.WS)


            self.state = 2378
            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, 252, self.RULE_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2382
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,391,self._ctx)
            if la_ == 1:
                self.state = 2380
                self.match(vbaParser.OPTIONAL)
                self.state = 2381
                self.match(vbaParser.WS)


            self.state = 2386
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,392,self._ctx)
            if la_ == 1:
                self.state = 2384
                _la = self._input.LA(1)
                if not(_la==21 or _la==22):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2385
                self.match(vbaParser.WS)


            self.state = 2390
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
            if la_ == 1:
                self.state = 2388
                self.match(vbaParser.PARAMARRAY)
                self.state = 2389
                self.match(vbaParser.WS)


            self.state = 2392
            self.ambiguousIdentifier()
            self.state = 2394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 2393
                self.typeHint()


            self.state = 2404
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,397,self._ctx)
            if la_ == 1:
                self.state = 2397
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2396
                    self.match(vbaParser.WS)


                self.state = 2399
                self.match(vbaParser.LPAREN)
                self.state = 2401
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2400
                    self.match(vbaParser.WS)


                self.state = 2403
                self.match(vbaParser.RPAREN)


            self.state = 2410
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,399,self._ctx)
            if la_ == 1:
                self.state = 2407
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2406
                    self.match(vbaParser.WS)


                self.state = 2409
                self.asTypeClause()


            self.state = 2416
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,401,self._ctx)
            if la_ == 1:
                self.state = 2413
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2412
                    self.match(vbaParser.WS)


                self.state = 2415
                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, 254, self.RULE_argDefaultValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2418
            self.match(vbaParser.EQ)
            self.state = 2420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2419
                self.match(vbaParser.WS)


            self.state = 2422
            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, 256, self.RULE_subscripts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2424
            self.subscript_()
            self.state = 2435
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,405,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2426
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2425
                        self.match(vbaParser.WS)


                    self.state = 2428
                    self.match(vbaParser.T__0)
                    self.state = 2430
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2429
                        self.match(vbaParser.WS)


                    self.state = 2432
                    self.subscript_() 
                self.state = 2437
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,405,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, 258, self.RULE_subscript_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,406,self._ctx)
            if la_ == 1:
                self.state = 2438
                self.valueStmt(0)
                self.state = 2439
                self.match(vbaParser.WS)
                self.state = 2440
                self.match(vbaParser.TO)
                self.state = 2441
                self.match(vbaParser.WS)


            self.state = 2445
            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, 260, self.RULE_ambiguousIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2449 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2449
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [220]:
                        self.state = 2447
                        self.match(vbaParser.IDENTIFIER)
                        pass
                    elif token in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 102, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 121, 122, 127, 128, 129, 130, 131, 132, 137, 138, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185]:
                        self.state = 2448
                        self.ambiguousKeyword()
                        pass
                    else:
                        raise NoViableAltException(self)


                else:
                    raise NoViableAltException(self)
                self.state = 2451 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,408,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, 262, self.RULE_asTypeClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2453
            self.match(vbaParser.AS)
            self.state = 2455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2454
                self.match(vbaParser.WS)


            self.state = 2459
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,410,self._ctx)
            if la_ == 1:
                self.state = 2457
                self.match(vbaParser.NEW)
                self.state = 2458
                self.match(vbaParser.WS)


            self.state = 2461
            self.type_()
            self.state = 2466
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,412,self._ctx)
            if la_ == 1:
                self.state = 2463
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2462
                    self.match(vbaParser.WS)


                self.state = 2465
                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, 264, self.RULE_baseType)
        self._la = 0 # Token type
        try:
            self.state = 2488
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2468
                self.match(vbaParser.BOOLEAN)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2469
                self.match(vbaParser.BYTE)
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2470
                self.match(vbaParser.COLLECTION)
                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2471
                self.match(vbaParser.DATE)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2472
                self.match(vbaParser.DOUBLE)
                pass
            elif token in [88]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2473
                self.match(vbaParser.INTEGER)
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2474
                self.match(vbaParser.LONG)
                pass
            elif token in [159]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2475
                self.match(vbaParser.SINGLE)
                pass
            elif token in [164]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2476
                self.match(vbaParser.STRING)
                self.state = 2485
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,415,self._ctx)
                if la_ == 1:
                    self.state = 2478
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2477
                        self.match(vbaParser.WS)


                    self.state = 2480
                    self.match(vbaParser.MULT)
                    self.state = 2482
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2481
                        self.match(vbaParser.WS)


                    self.state = 2484
                    self.valueStmt(0)


                pass
            elif token in [177]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2487
                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, 266, self.RULE_certainIdentifier)
        try:
            self.state = 2505
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [220]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2490
                self.match(vbaParser.IDENTIFIER)
                self.state = 2495
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,418,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2493
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 102, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 121, 122, 127, 128, 129, 130, 131, 132, 137, 138, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185]:
                            self.state = 2491
                            self.ambiguousKeyword()
                            pass
                        elif token in [220]:
                            self.state = 2492
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 2497
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,418,self._ctx)

                pass
            elif token in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 102, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 121, 122, 127, 128, 129, 130, 131, 132, 137, 138, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2498
                self.ambiguousKeyword()
                self.state = 2501 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2501
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 102, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 121, 122, 127, 128, 129, 130, 131, 132, 137, 138, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185]:
                            self.state = 2499
                            self.ambiguousKeyword()
                            pass
                        elif token in [220]:
                            self.state = 2500
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)


                    else:
                        raise NoViableAltException(self)
                    self.state = 2503 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,420,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, 268, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2507
            _la = self._input.LA(1)
            if not(_la==87 or _la==97 or ((((_la - 189)) & ~0x3f) == 0 and ((1 << (_la - 189)) & 559) != 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, 270, self.RULE_complexType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2509
            self.ambiguousIdentifier()
            self.state = 2514
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,422,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2510
                    _la = self._input.LA(1)
                    if not(_la==4 or _la==5):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2511
                    self.ambiguousIdentifier() 
                self.state = 2516
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,422,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, 272, self.RULE_fieldLength)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2517
            self.match(vbaParser.MULT)
            self.state = 2519
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2518
                self.match(vbaParser.WS)


            self.state = 2523
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [209]:
                self.state = 2521
                self.match(vbaParser.INTEGERLITERAL)
                pass
            elif token in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 102, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 121, 122, 127, 128, 129, 130, 131, 132, 137, 138, 139, 140, 141, 142, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 220]:
                self.state = 2522
                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, 274, self.RULE_letterrange)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2525
            self.certainIdentifier()
            self.state = 2534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
            if la_ == 1:
                self.state = 2527
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2526
                    self.match(vbaParser.WS)


                self.state = 2529
                self.match(vbaParser.MINUS)
                self.state = 2531
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2530
                    self.match(vbaParser.WS)


                self.state = 2533
                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, 276, self.RULE_lineLabel)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2536
            self.ambiguousIdentifier()
            self.state = 2537
            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, 278, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2539
            _la = self._input.LA(1)
            if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & 26388279066625) != 0) or ((((_la - 171)) & ~0x3f) == 0 and ((1 << (_la - 171)) & 2181843386369) != 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, 280, self.RULE_type_)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2543
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,428,self._ctx)
            if la_ == 1:
                self.state = 2541
                self.baseType()
                pass

            elif la_ == 2:
                self.state = 2542
                self.complexType()
                pass


            self.state = 2553
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,431,self._ctx)
            if la_ == 1:
                self.state = 2546
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2545
                    self.match(vbaParser.WS)


                self.state = 2548
                self.match(vbaParser.LPAREN)
                self.state = 2550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2549
                    self.match(vbaParser.WS)


                self.state = 2552
                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, 282, self.RULE_typeHint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2555
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186):
                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, 284, self.RULE_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2557
            _la = self._input.LA(1)
            if not(((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 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, 286, self.RULE_ambiguousKeyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2559
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -4593671619917906432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8755014975736513009) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 288230376151678495) != 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, 288, self.RULE_remComment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2561
            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, 290, self.RULE_comment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2563
            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, 292, self.RULE_endOfLine)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2566
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2565
                self.match(vbaParser.WS)


            self.state = 2571
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [213]:
                self.state = 2568
                self.match(vbaParser.NEWLINE)
                pass
            elif token in [215]:
                self.state = 2569
                self.comment()
                pass
            elif token in [214]:
                self.state = 2570
                self.remComment()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2574
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,434,self._ctx)
            if la_ == 1:
                self.state = 2573
                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, 294, self.RULE_endOfStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2586
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,438,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2584
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,437,self._ctx)
                    if la_ == 1:
                        self.state = 2576
                        self.endOfLine()
                        pass

                    elif la_ == 2:
                        self.state = 2578
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2577
                            self.match(vbaParser.WS)


                        self.state = 2580
                        self.match(vbaParser.COLON)
                        self.state = 2582
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,436,self._ctx)
                        if la_ == 1:
                            self.state = 2581
                            self.match(vbaParser.WS)


                        pass

             
                self.state = 2588
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,438,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[101] = 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, 14)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 1)
         




