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

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_loadStmt = 51
    RULE_lockStmt = 52
    RULE_lsetStmt = 53
    RULE_macroConstStmt = 54
    RULE_macroIfThenElseStmt = 55
    RULE_macroIfBlockStmt = 56
    RULE_macroElseIfBlockStmt = 57
    RULE_macroElseBlockStmt = 58
    RULE_midStmt = 59
    RULE_mkdirStmt = 60
    RULE_nameStmt = 61
    RULE_onErrorStmt = 62
    RULE_onGoToStmt = 63
    RULE_onGoSubStmt = 64
    RULE_openStmt = 65
    RULE_outputList = 66
    RULE_outputList_Expression = 67
    RULE_printStmt = 68
    RULE_propertyGetStmt = 69
    RULE_propertySetStmt = 70
    RULE_propertyLetStmt = 71
    RULE_putStmt = 72
    RULE_raiseEventStmt = 73
    RULE_randomizeStmt = 74
    RULE_redimStmt = 75
    RULE_redimSubStmt = 76
    RULE_resetStmt = 77
    RULE_resumeStmt = 78
    RULE_returnStmt = 79
    RULE_rmdirStmt = 80
    RULE_rsetStmt = 81
    RULE_savepictureStmt = 82
    RULE_saveSettingStmt = 83
    RULE_seekStmt = 84
    RULE_selectCaseStmt = 85
    RULE_sC_Selection = 86
    RULE_sC_Case = 87
    RULE_sC_Cond = 88
    RULE_sendkeysStmt = 89
    RULE_setattrStmt = 90
    RULE_setStmt = 91
    RULE_stopStmt = 92
    RULE_subStmt = 93
    RULE_timeStmt = 94
    RULE_typeStmt = 95
    RULE_typeStmt_Element = 96
    RULE_typeOfStmt = 97
    RULE_unloadStmt = 98
    RULE_unlockStmt = 99
    RULE_valueStmt = 100
    RULE_variableStmt = 101
    RULE_variableListStmt = 102
    RULE_variableSubStmt = 103
    RULE_whileWendStmt = 104
    RULE_widthStmt = 105
    RULE_withStmt = 106
    RULE_writeStmt = 107
    RULE_fileNumber = 108
    RULE_explicitCallStmt = 109
    RULE_eCS_ProcedureCall = 110
    RULE_eCS_MemberProcedureCall = 111
    RULE_implicitCallStmt_InBlock = 112
    RULE_iCS_B_MemberProcedureCall = 113
    RULE_iCS_B_ProcedureCall = 114
    RULE_implicitCallStmt_InStmt = 115
    RULE_iCS_S_VariableOrProcedureCall = 116
    RULE_iCS_S_ProcedureOrArrayCall = 117
    RULE_iCS_S_MembersCall = 118
    RULE_iCS_S_MemberCall = 119
    RULE_iCS_S_DictionaryCall = 120
    RULE_argsCall = 121
    RULE_argCall = 122
    RULE_dictionaryCallStmt = 123
    RULE_argList = 124
    RULE_arg = 125
    RULE_argDefaultValue = 126
    RULE_subscripts = 127
    RULE_subscript_ = 128
    RULE_ambiguousIdentifier = 129
    RULE_asTypeClause = 130
    RULE_baseType = 131
    RULE_certainIdentifier = 132
    RULE_comparisonOperator = 133
    RULE_complexType = 134
    RULE_fieldLength = 135
    RULE_letterrange = 136
    RULE_lineLabel = 137
    RULE_literal = 138
    RULE_type_ = 139
    RULE_typeHint = 140
    RULE_visibility = 141
    RULE_ambiguousKeyword = 142
    RULE_remComment = 143
    RULE_comment = 144
    RULE_endOfLine = 145
    RULE_endOfStatement = 146

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

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

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




    class StartRuleContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return vbaParser.RULE_startRule

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

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




    def startRule(self):

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


    class ModuleContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_module

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

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




    def module(self):

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


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

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



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


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

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


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

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


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

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


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

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


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


    class ModuleHeaderContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_moduleHeader

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

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




    def moduleHeader(self):

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


    class ModuleConfigContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleConfig

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

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




    def moduleConfig(self):

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

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

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

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


    class ModuleConfigElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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

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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleConfigElement

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

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




    def moduleConfigElement(self):

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


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


            self.state = 382
            self.literal()
            self.state = 386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & 71) != 0):
                self.state = 383
                self.endOfLine()
                self.state = 388
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class ModuleAttributesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleAttributes

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

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




    def moduleAttributes(self):

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

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

                self.state = 397 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==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 = 399
            self.moduleDeclarationsElement()
            self.state = 409
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 401 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 400
                            self.endOfLine()

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

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

            self.state = 415
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 412
                    self.endOfLine() 
                self.state = 417
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

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


    class ModuleOptionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleOption

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



    class OptionExplicitStmtContext(ModuleOptionContext):

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

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

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

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


    class OptionBaseStmtContext(ModuleOptionContext):

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

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

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

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


    class OptionPrivateModuleStmtContext(ModuleOptionContext):

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

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

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

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


    class OptionCompareStmtContext(ModuleOptionContext):

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

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

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

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



    def moduleOption(self):

        localctx = vbaParser.ModuleOptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_moduleOption)
        self._la = 0 # Token type
        try:
            self.state = 426
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [123]:
                localctx = vbaParser.OptionBaseStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 418
                self.match(vbaParser.OPTION_BASE)
                self.state = 419
                self.match(vbaParser.WS)
                self.state = 420
                self.match(vbaParser.SHORTLITERAL)
                pass
            elif token in [125]:
                localctx = vbaParser.OptionCompareStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 421
                self.match(vbaParser.OPTION_COMPARE)
                self.state = 422
                self.match(vbaParser.WS)
                self.state = 423
                _la = self._input.LA(1)
                if not(_la==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 = 424
                self.match(vbaParser.OPTION_EXPLICIT)
                pass
            elif token in [126]:
                localctx = vbaParser.OptionPrivateModuleStmtContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 425
                self.match(vbaParser.OPTION_PRIVATE_MODULE)
                pass
            else:
                raise NoViableAltException(self)

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


    class ModuleDeclarationsElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleDeclarationsElement

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

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




    def moduleDeclarationsElement(self):

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

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

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

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

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

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

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

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

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

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


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


    class MacroStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_macroStmt

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

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




    def macroStmt(self):

        localctx = vbaParser.MacroStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_macroStmt)
        try:
            self.state = 442
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [103]:
                self.enterOuterAlt(localctx, 1)
                self.state = 440
                self.macroConstStmt()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 2)
                self.state = 441
                self.macroIfThenElseStmt()
                pass
            else:
                raise NoViableAltException(self)

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


    class ModuleBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleBody

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

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




    def moduleBody(self):

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

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

            self.state = 460
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 457
                    self.endOfLine() 
                self.state = 462
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)

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


    class ModuleBodyElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_moduleBodyElement

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

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




    def moduleBodyElement(self):

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

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

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

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

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

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


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


    class AttributeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return vbaParser.RULE_attributeStmt

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

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




    def attributeStmt(self):

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


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


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


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


                    self.state = 489
                    self.literal() 
                self.state = 494
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

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


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_block

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

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




    def block(self):

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

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


    class BlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_blockStmt

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

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




    def blockStmt(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


    class AppactivateStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_appactivateStmt

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

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




    def appactivateStmt(self):

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


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


                self.state = 586
                self.valueStmt(0)


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


    class BeepStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_beepStmt

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

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




    def beepStmt(self):

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


    class ChdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_chdirStmt

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

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




    def chdirStmt(self):

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


    class ChdriveStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_chdriveStmt

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

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




    def chdriveStmt(self):

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


    class CloseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_closeStmt

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

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




    def closeStmt(self):

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


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


                        self.state = 609
                        self.fileNumber() 
                    self.state = 614
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,42,self._ctx)



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


    class ConstStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_constStmt

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

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




    def constStmt(self):

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


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


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


                    self.state = 632
                    self.constSubStmt() 
                self.state = 637
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,self._ctx)

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


    class ConstSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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


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

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


        def getRuleIndex(self):
            return vbaParser.RULE_constSubStmt

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

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




    def constSubStmt(self):

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


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


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


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


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


    class DateStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

        def getRuleIndex(self):
            return vbaParser.RULE_dateStmt

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

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




    def dateStmt(self):

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


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


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


    class DeclareStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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

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


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

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


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

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


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


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

        def getRuleIndex(self):
            return vbaParser.RULE_declareStmt

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

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




    def declareStmt(self):

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


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


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


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

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


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


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


                self.state = 701
                self.argList()


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


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


    class DeftypeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_deftypeStmt

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

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




    def deftypeStmt(self):

        localctx = vbaParser.DeftypeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_deftypeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 708
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 140703128616960) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 709
            self.match(vbaParser.WS)
            self.state = 710
            self.letterrange()
            self.state = 721
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 712
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 711
                        self.match(vbaParser.WS)


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


                    self.state = 718
                    self.letterrange() 
                self.state = 723
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)

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


    class DeleteSettingStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_deleteSettingStmt

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

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




    def deleteSettingStmt(self):

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


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


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


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


                self.state = 742
                self.valueStmt(0)


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


    class DoLoopStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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

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


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_doLoopStmt

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

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




    def doLoopStmt(self):

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


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

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


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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 763
                self.match(vbaParser.DO)
                self.state = 764
                self.endOfStatement()
                self.state = 765
                self.block()
                self.state = 766
                self.match(vbaParser.LOOP)
                self.state = 767
                self.match(vbaParser.WS)
                self.state = 768
                _la = self._input.LA(1)
                if not(_la==176 or _la==180):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 769
                self.match(vbaParser.WS)
                self.state = 770
                self.valueStmt(0)
                pass


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


    class EndStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_endStmt

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

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




    def endStmt(self):

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


    class EnumerationStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_enumerationStmt

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

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




    def enumerationStmt(self):

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


            self.state = 781
            self.match(vbaParser.ENUM)
            self.state = 782
            self.match(vbaParser.WS)
            self.state = 783
            self.ambiguousIdentifier()
            self.state = 784
            self.endOfStatement()
            self.state = 788
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 = 785
                self.enumerationStmt_Constant()
                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class EnumerationStmt_ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

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


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

        def getRuleIndex(self):
            return vbaParser.RULE_enumerationStmt_Constant

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

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




    def enumerationStmt_Constant(self):

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


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


                self.state = 801
                self.valueStmt(0)


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


    class EraseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_eraseStmt

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

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




    def eraseStmt(self):

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


                    self.state = 813
                    self.valueStmt(0) 
                self.state = 818
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,80,self._ctx)

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


    class ErrorStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_errorStmt

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

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




    def errorStmt(self):

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


    class EventStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_eventStmt

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

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




    def eventStmt(self):

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


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


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


    class ExitStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_exitStmt

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

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




    def exitStmt(self):

        localctx = vbaParser.ExitStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_exitStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 836
            _la = self._input.LA(1)
            if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 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 = 838
            self.match(vbaParser.FILECOPY)
            self.state = 839
            self.match(vbaParser.WS)
            self.state = 840
            self.valueStmt(0)
            self.state = 842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 841
                self.match(vbaParser.WS)


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


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


    class ForEachStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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

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


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


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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_forEachStmt

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

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




    def forEachStmt(self):

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


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


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


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


    class ForNextStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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

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


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

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


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


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

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


        def getRuleIndex(self):
            return vbaParser.RULE_forNextStmt

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

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




    def forNextStmt(self):

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


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


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


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


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


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


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


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


    class FunctionStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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

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


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

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

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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_functionStmt

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

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




    def functionStmt(self):

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


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


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


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


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


                self.state = 928
                self.argList()


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


                self.state = 934
                self.asTypeClause()


            self.state = 937
            self.endOfStatement()
            self.state = 939
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 938
                self.block()


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


    class GetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_getStmt

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

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




    def getStmt(self):

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


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


            self.state = 954
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 = 953
                self.valueStmt(0)


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


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


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


    class GoSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_goSubStmt

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

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




    def goSubStmt(self):

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


    class GoToStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_goToStmt

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

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




    def goToStmt(self):

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


    class IfThenElseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return vbaParser.RULE_ifThenElseStmt

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



    class BlockIfThenElseContext(IfThenElseStmtContext):

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

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

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

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


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

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


    class InlineIfThenElseContext(IfThenElseStmtContext):

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

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

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

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

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

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



    def ifThenElseStmt(self):

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


                pass

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

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


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


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


    class IfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_ifBlockStmt

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

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




    def ifBlockStmt(self):

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


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


    class IfConditionStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_ifConditionStmt

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

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




    def ifConditionStmt(self):

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


    class IfElseIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_ifElseIfBlockStmt

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

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




    def ifElseIfBlockStmt(self):

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


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


    class IfElseBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_ifElseBlockStmt

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

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




    def ifElseBlockStmt(self):

        localctx = vbaParser.IfElseBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_ifElseBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            self.match(vbaParser.ELSE)
            self.state = 1021
            self.endOfStatement()
            self.state = 1023
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 1022
                self.block()


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


    class ImplementsStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_implementsStmt

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

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




    def implementsStmt(self):

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


    class InputStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_inputStmt

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

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




    def inputStmt(self):

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


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


                    self.state = 1039
                    self.valueStmt(0)

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

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


    class KillStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_killStmt

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

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




    def killStmt(self):

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


    class LetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

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

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

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

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

        def getRuleIndex(self):
            return vbaParser.RULE_letStmt

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

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




    def letStmt(self):

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


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


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


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


    class LineInputStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_lineInputStmt

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

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




    def lineInputStmt(self):

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


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


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


    class LoadStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return vbaParser.RULE_loadStmt

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

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




    def loadStmt(self):

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


    class LockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

        def getRuleIndex(self):
            return vbaParser.RULE_lockStmt

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

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




    def lockStmt(self):

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


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


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




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


    class LsetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return vbaParser.RULE_lsetStmt

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

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




    def lsetStmt(self):

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


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


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


    class MacroConstStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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

        def getRuleIndex(self):
            return vbaParser.RULE_macroConstStmt

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

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




    def macroConstStmt(self):

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


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


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


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


    class MacroIfThenElseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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


        def getRuleIndex(self):
            return vbaParser.RULE_macroIfThenElseStmt

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

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




    def macroIfThenElseStmt(self):

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

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


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


    class MacroIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_macroIfBlockStmt

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

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




    def macroIfBlockStmt(self):

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


            self.state = 1139
            self.ifConditionStmt()
            self.state = 1140
            self.match(vbaParser.WS)
            self.state = 1141
            self.match(vbaParser.THEN)
            self.state = 1142
            self.endOfStatement()
            self.state = 1148
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 - 212)) & ~0x3f) == 0 and ((1 << (_la - 212)) & 265) != 0):
                self.state = 1146
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                if la_ == 1:
                    self.state = 1143
                    self.moduleDeclarations()
                    pass

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

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


                self.state = 1150
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class MacroElseIfBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_macroElseIfBlockStmt

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

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




    def macroElseIfBlockStmt(self):

        localctx = vbaParser.MacroElseIfBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_macroElseIfBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1151
            self.match(vbaParser.MACRO_ELSEIF)
            self.state = 1153
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==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 - 212)) & ~0x3f) == 0 and ((1 << (_la - 212)) & 265) != 0):
                self.state = 1162
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                if la_ == 1:
                    self.state = 1159
                    self.moduleDeclarations()
                    pass

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

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


                self.state = 1166
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class MacroElseBlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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


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


        def getRuleIndex(self):
            return vbaParser.RULE_macroElseBlockStmt

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

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




    def macroElseBlockStmt(self):

        localctx = vbaParser.MacroElseBlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_macroElseBlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1167
            self.match(vbaParser.MACRO_ELSE)
            self.state = 1168
            self.endOfStatement()
            self.state = 1174
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 - 212)) & ~0x3f) == 0 and ((1 << (_la - 212)) & 265) != 0):
                self.state = 1172
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                if la_ == 1:
                    self.state = 1169
                    self.moduleDeclarations()
                    pass

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

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


                self.state = 1176
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class MidStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


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

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

        def getRuleIndex(self):
            return vbaParser.RULE_midStmt

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

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




    def midStmt(self):

        localctx = vbaParser.MidStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_midStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            self.match(vbaParser.MID)
            self.state = 1179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1178
                self.match(vbaParser.WS)


            self.state = 1181
            self.match(vbaParser.LPAREN)
            self.state = 1183
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1182
                self.match(vbaParser.WS)


            self.state = 1185
            self.argsCall()
            self.state = 1187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1186
                self.match(vbaParser.WS)


            self.state = 1189
            self.match(vbaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MkdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MKDIR(self):
            return self.getToken(vbaParser.MKDIR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_mkdirStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMkdirStmt" ):
                listener.enterMkdirStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMkdirStmt" ):
                listener.exitMkdirStmt(self)




    def mkdirStmt(self):

        localctx = vbaParser.MkdirStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_mkdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1191
            self.match(vbaParser.MKDIR)
            self.state = 1192
            self.match(vbaParser.WS)
            self.state = 1193
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAME(self):
            return self.getToken(vbaParser.NAME, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_nameStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNameStmt" ):
                listener.enterNameStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNameStmt" ):
                listener.exitNameStmt(self)




    def nameStmt(self):

        localctx = vbaParser.NameStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_nameStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1195
            self.match(vbaParser.NAME)
            self.state = 1196
            self.match(vbaParser.WS)
            self.state = 1197
            self.valueStmt(0)
            self.state = 1198
            self.match(vbaParser.WS)
            self.state = 1199
            self.match(vbaParser.AS)
            self.state = 1200
            self.match(vbaParser.WS)
            self.state = 1201
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OnErrorStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ON_ERROR(self):
            return self.getToken(vbaParser.ON_ERROR, 0)

        def ON_LOCAL_ERROR(self):
            return self.getToken(vbaParser.ON_LOCAL_ERROR, 0)

        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def RESUME(self):
            return self.getToken(vbaParser.RESUME, 0)

        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onErrorStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOnErrorStmt" ):
                listener.enterOnErrorStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOnErrorStmt" ):
                listener.exitOnErrorStmt(self)




    def onErrorStmt(self):

        localctx = vbaParser.OnErrorStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_onErrorStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            _la = self._input.LA(1)
            if not(_la==119 or _la==120):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1204
            self.match(vbaParser.WS)
            self.state = 1211
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 1205
                self.match(vbaParser.GOTO)
                self.state = 1206
                self.match(vbaParser.WS)
                self.state = 1207
                self.valueStmt(0)
                pass
            elif token in [147]:
                self.state = 1208
                self.match(vbaParser.RESUME)
                self.state = 1209
                self.match(vbaParser.WS)
                self.state = 1210
                self.match(vbaParser.NEXT)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OnGoToStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(vbaParser.ON, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def GOTO(self):
            return self.getToken(vbaParser.GOTO, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onGoToStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOnGoToStmt" ):
                listener.enterOnGoToStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOnGoToStmt" ):
                listener.exitOnGoToStmt(self)




    def onGoToStmt(self):

        localctx = vbaParser.OnGoToStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_onGoToStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1213
            self.match(vbaParser.ON)
            self.state = 1214
            self.match(vbaParser.WS)
            self.state = 1215
            self.valueStmt(0)
            self.state = 1216
            self.match(vbaParser.WS)
            self.state = 1217
            self.match(vbaParser.GOTO)
            self.state = 1218
            self.match(vbaParser.WS)
            self.state = 1219
            self.valueStmt(0)
            self.state = 1230
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,149,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1221
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1220
                        self.match(vbaParser.WS)


                    self.state = 1223
                    self.match(vbaParser.T__0)
                    self.state = 1225
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1224
                        self.match(vbaParser.WS)


                    self.state = 1227
                    self.valueStmt(0) 
                self.state = 1232
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,149,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OnGoSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(vbaParser.ON, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def GOSUB(self):
            return self.getToken(vbaParser.GOSUB, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_onGoSubStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOnGoSubStmt" ):
                listener.enterOnGoSubStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOnGoSubStmt" ):
                listener.exitOnGoSubStmt(self)




    def onGoSubStmt(self):

        localctx = vbaParser.OnGoSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_onGoSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1233
            self.match(vbaParser.ON)
            self.state = 1234
            self.match(vbaParser.WS)
            self.state = 1235
            self.valueStmt(0)
            self.state = 1236
            self.match(vbaParser.WS)
            self.state = 1237
            self.match(vbaParser.GOSUB)
            self.state = 1238
            self.match(vbaParser.WS)
            self.state = 1239
            self.valueStmt(0)
            self.state = 1250
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,152,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1241
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1240
                        self.match(vbaParser.WS)


                    self.state = 1243
                    self.match(vbaParser.T__0)
                    self.state = 1245
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1244
                        self.match(vbaParser.WS)


                    self.state = 1247
                    self.valueStmt(0) 
                self.state = 1252
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,152,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OpenStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN(self):
            return self.getToken(vbaParser.OPEN, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def FOR(self):
            return self.getToken(vbaParser.FOR, 0)

        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def APPEND(self):
            return self.getToken(vbaParser.APPEND, 0)

        def BINARY(self):
            return self.getToken(vbaParser.BINARY, 0)

        def INPUT(self):
            return self.getToken(vbaParser.INPUT, 0)

        def OUTPUT(self):
            return self.getToken(vbaParser.OUTPUT, 0)

        def RANDOM(self):
            return self.getToken(vbaParser.RANDOM, 0)

        def ACCESS(self):
            return self.getToken(vbaParser.ACCESS, 0)

        def LEN(self):
            return self.getToken(vbaParser.LEN, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def READ(self):
            return self.getToken(vbaParser.READ, 0)

        def WRITE(self):
            return self.getToken(vbaParser.WRITE, 0)

        def READ_WRITE(self):
            return self.getToken(vbaParser.READ_WRITE, 0)

        def SHARED(self):
            return self.getToken(vbaParser.SHARED, 0)

        def LOCK_READ(self):
            return self.getToken(vbaParser.LOCK_READ, 0)

        def LOCK_WRITE(self):
            return self.getToken(vbaParser.LOCK_WRITE, 0)

        def LOCK_READ_WRITE(self):
            return self.getToken(vbaParser.LOCK_READ_WRITE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_openStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOpenStmt" ):
                listener.enterOpenStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOpenStmt" ):
                listener.exitOpenStmt(self)




    def openStmt(self):

        localctx = vbaParser.OpenStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_openStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1253
            self.match(vbaParser.OPEN)
            self.state = 1254
            self.match(vbaParser.WS)
            self.state = 1255
            self.valueStmt(0)
            self.state = 1256
            self.match(vbaParser.WS)
            self.state = 1257
            self.match(vbaParser.FOR)
            self.state = 1258
            self.match(vbaParser.WS)
            self.state = 1259
            _la = self._input.LA(1)
            if not(_la==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 = 1264
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.state = 1260
                self.match(vbaParser.WS)
                self.state = 1261
                self.match(vbaParser.ACCESS)
                self.state = 1262
                self.match(vbaParser.WS)
                self.state = 1263
                _la = self._input.LA(1)
                if not(((((_la - 142)) & ~0x3f) == 0 and ((1 << (_la - 142)) & 4398046511107) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1268
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
            if la_ == 1:
                self.state = 1266
                self.match(vbaParser.WS)
                self.state = 1267
                _la = self._input.LA(1)
                if not(((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 576460752303423495) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1270
            self.match(vbaParser.WS)
            self.state = 1271
            self.match(vbaParser.AS)
            self.state = 1272
            self.match(vbaParser.WS)
            self.state = 1273
            self.fileNumber()
            self.state = 1284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
            if la_ == 1:
                self.state = 1274
                self.match(vbaParser.WS)
                self.state = 1275
                self.match(vbaParser.LEN)
                self.state = 1277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1276
                    self.match(vbaParser.WS)


                self.state = 1279
                self.match(vbaParser.EQ)
                self.state = 1281
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1280
                    self.match(vbaParser.WS)


                self.state = 1283
                self.valueStmt(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OutputListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def outputList_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.OutputList_ExpressionContext)
            else:
                return self.getTypedRuleContext(vbaParser.OutputList_ExpressionContext,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_outputList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOutputList" ):
                listener.enterOutputList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOutputList" ):
                listener.exitOutputList(self)




    def outputList(self):

        localctx = vbaParser.OutputListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_outputList)
        self._la = 0 # Token type
        try:
            self.state = 1319
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1286
                self.outputList_Expression()
                self.state = 1299
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1288
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1287
                            self.match(vbaParser.WS)


                        self.state = 1290
                        _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 = 1292
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
                        if la_ == 1:
                            self.state = 1291
                            self.match(vbaParser.WS)


                        self.state = 1295
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                        if la_ == 1:
                            self.state = 1294
                            self.outputList_Expression()

                 
                    self.state = 1301
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 = 1302
                    self.outputList_Expression()


                self.state = 1315 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1306
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1305
                            self.match(vbaParser.WS)


                        self.state = 1308
                        _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 = 1310
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                        if la_ == 1:
                            self.state = 1309
                            self.match(vbaParser.WS)


                        self.state = 1313
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                        if la_ == 1:
                            self.state = 1312
                            self.outputList_Expression()



                    else:
                        raise NoViableAltException(self)
                    self.state = 1317 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,166,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OutputList_ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def SPC(self):
            return self.getToken(vbaParser.SPC, 0)

        def TAB(self):
            return self.getToken(vbaParser.TAB, 0)

        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_outputList_Expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOutputList_Expression" ):
                listener.enterOutputList_Expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOutputList_Expression" ):
                listener.exitOutputList_Expression(self)




    def outputList_Expression(self):

        localctx = vbaParser.OutputList_ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_outputList_Expression)
        self._la = 0 # Token type
        try:
            self.state = 1338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1321
                self.valueStmt(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1322
                _la = self._input.LA(1)
                if not(_la==160 or _la==166):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1336
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1324
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1323
                        self.match(vbaParser.WS)


                    self.state = 1326
                    self.match(vbaParser.LPAREN)
                    self.state = 1328
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                    if la_ == 1:
                        self.state = 1327
                        self.match(vbaParser.WS)


                    self.state = 1330
                    self.argsCall()
                    self.state = 1332
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1331
                        self.match(vbaParser.WS)


                    self.state = 1334
                    self.match(vbaParser.RPAREN)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrintStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PRINT(self):
            return self.getToken(vbaParser.PRINT, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def outputList(self):
            return self.getTypedRuleContext(vbaParser.OutputListContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_printStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrintStmt" ):
                listener.enterPrintStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrintStmt" ):
                listener.exitPrintStmt(self)




    def printStmt(self):

        localctx = vbaParser.PrintStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_printStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1340
            self.match(vbaParser.PRINT)
            self.state = 1341
            self.match(vbaParser.WS)
            self.state = 1342
            self.fileNumber()
            self.state = 1344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1343
                self.match(vbaParser.WS)


            self.state = 1346
            self.match(vbaParser.T__0)
            self.state = 1351
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                self.state = 1348
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                if la_ == 1:
                    self.state = 1347
                    self.match(vbaParser.WS)


                self.state = 1350
                self.outputList()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyGetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROPERTY_GET(self):
            return self.getToken(vbaParser.PROPERTY_GET, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertyGetStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPropertyGetStmt" ):
                listener.enterPropertyGetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPropertyGetStmt" ):
                listener.exitPropertyGetStmt(self)




    def propertyGetStmt(self):

        localctx = vbaParser.PropertyGetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_propertyGetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1353
                self.visibility()
                self.state = 1354
                self.match(vbaParser.WS)


            self.state = 1360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1358
                self.match(vbaParser.STATIC)
                self.state = 1359
                self.match(vbaParser.WS)


            self.state = 1362
            self.match(vbaParser.PROPERTY_GET)
            self.state = 1363
            self.match(vbaParser.WS)
            self.state = 1364
            self.ambiguousIdentifier()
            self.state = 1366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 1365
                self.typeHint()


            self.state = 1372
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1369
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1368
                    self.match(vbaParser.WS)


                self.state = 1371
                self.argList()


            self.state = 1376
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1374
                self.match(vbaParser.WS)
                self.state = 1375
                self.asTypeClause()


            self.state = 1378
            self.endOfStatement()
            self.state = 1380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 1379
                self.block()


            self.state = 1382
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertySetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROPERTY_SET(self):
            return self.getToken(vbaParser.PROPERTY_SET, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertySetStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPropertySetStmt" ):
                listener.enterPropertySetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPropertySetStmt" ):
                listener.exitPropertySetStmt(self)




    def propertySetStmt(self):

        localctx = vbaParser.PropertySetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_propertySetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1384
                self.visibility()
                self.state = 1385
                self.match(vbaParser.WS)


            self.state = 1391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1389
                self.match(vbaParser.STATIC)
                self.state = 1390
                self.match(vbaParser.WS)


            self.state = 1393
            self.match(vbaParser.PROPERTY_SET)
            self.state = 1394
            self.match(vbaParser.WS)
            self.state = 1395
            self.ambiguousIdentifier()
            self.state = 1400
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
            if la_ == 1:
                self.state = 1397
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1396
                    self.match(vbaParser.WS)


                self.state = 1399
                self.argList()


            self.state = 1402
            self.endOfStatement()
            self.state = 1404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 1403
                self.block()


            self.state = 1406
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PropertyLetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROPERTY_LET(self):
            return self.getToken(vbaParser.PROPERTY_LET, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_PROPERTY(self):
            return self.getToken(vbaParser.END_PROPERTY, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_propertyLetStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPropertyLetStmt" ):
                listener.enterPropertyLetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPropertyLetStmt" ):
                listener.exitPropertyLetStmt(self)




    def propertyLetStmt(self):

        localctx = vbaParser.PropertyLetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_propertyLetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1408
                self.visibility()
                self.state = 1409
                self.match(vbaParser.WS)


            self.state = 1415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1413
                self.match(vbaParser.STATIC)
                self.state = 1414
                self.match(vbaParser.WS)


            self.state = 1417
            self.match(vbaParser.PROPERTY_LET)
            self.state = 1418
            self.match(vbaParser.WS)
            self.state = 1419
            self.ambiguousIdentifier()
            self.state = 1424
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
            if la_ == 1:
                self.state = 1421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1420
                    self.match(vbaParser.WS)


                self.state = 1423
                self.argList()


            self.state = 1426
            self.endOfStatement()
            self.state = 1428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 1427
                self.block()


            self.state = 1430
            self.match(vbaParser.END_PROPERTY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PutStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PUT(self):
            return self.getToken(vbaParser.PUT, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_putStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPutStmt" ):
                listener.enterPutStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPutStmt" ):
                listener.exitPutStmt(self)




    def putStmt(self):

        localctx = vbaParser.PutStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_putStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1432
            self.match(vbaParser.PUT)
            self.state = 1433
            self.match(vbaParser.WS)
            self.state = 1434
            self.fileNumber()
            self.state = 1436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1435
                self.match(vbaParser.WS)


            self.state = 1438
            self.match(vbaParser.T__0)
            self.state = 1440
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1439
                self.match(vbaParser.WS)


            self.state = 1443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 = 1442
                self.valueStmt(0)


            self.state = 1446
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1445
                self.match(vbaParser.WS)


            self.state = 1448
            self.match(vbaParser.T__0)
            self.state = 1450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1449
                self.match(vbaParser.WS)


            self.state = 1452
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RaiseEventStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RAISEEVENT(self):
            return self.getToken(vbaParser.RAISEEVENT, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_raiseEventStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRaiseEventStmt" ):
                listener.enterRaiseEventStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRaiseEventStmt" ):
                listener.exitRaiseEventStmt(self)




    def raiseEventStmt(self):

        localctx = vbaParser.RaiseEventStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_raiseEventStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1454
            self.match(vbaParser.RAISEEVENT)
            self.state = 1455
            self.match(vbaParser.WS)
            self.state = 1456
            self.ambiguousIdentifier()
            self.state = 1471
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
            if la_ == 1:
                self.state = 1458
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1457
                    self.match(vbaParser.WS)


                self.state = 1460
                self.match(vbaParser.LPAREN)
                self.state = 1462
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
                if la_ == 1:
                    self.state = 1461
                    self.match(vbaParser.WS)


                self.state = 1468
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                if la_ == 1:
                    self.state = 1464
                    self.argsCall()
                    self.state = 1466
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1465
                        self.match(vbaParser.WS)




                self.state = 1470
                self.match(vbaParser.RPAREN)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RandomizeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RANDOMIZE(self):
            return self.getToken(vbaParser.RANDOMIZE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_randomizeStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRandomizeStmt" ):
                listener.enterRandomizeStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRandomizeStmt" ):
                listener.exitRandomizeStmt(self)




    def randomizeStmt(self):

        localctx = vbaParser.RandomizeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_randomizeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1473
            self.match(vbaParser.RANDOMIZE)
            self.state = 1476
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.state = 1474
                self.match(vbaParser.WS)
                self.state = 1475
                self.valueStmt(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RedimStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REDIM(self):
            return self.getToken(vbaParser.REDIM, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def redimSubStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.RedimSubStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.RedimSubStmtContext,i)


        def PRESERVE(self):
            return self.getToken(vbaParser.PRESERVE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_redimStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRedimStmt" ):
                listener.enterRedimStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRedimStmt" ):
                listener.exitRedimStmt(self)




    def redimStmt(self):

        localctx = vbaParser.RedimStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_redimStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1478
            self.match(vbaParser.REDIM)
            self.state = 1479
            self.match(vbaParser.WS)
            self.state = 1482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
            if la_ == 1:
                self.state = 1480
                self.match(vbaParser.PRESERVE)
                self.state = 1481
                self.match(vbaParser.WS)


            self.state = 1484
            self.redimSubStmt()
            self.state = 1495
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1486
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1485
                        self.match(vbaParser.WS)


                    self.state = 1488
                    self.match(vbaParser.T__0)
                    self.state = 1490
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1489
                        self.match(vbaParser.WS)


                    self.state = 1492
                    self.redimSubStmt() 
                self.state = 1497
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,207,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RedimSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_redimSubStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRedimSubStmt" ):
                listener.enterRedimSubStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRedimSubStmt" ):
                listener.exitRedimSubStmt(self)




    def redimSubStmt(self):

        localctx = vbaParser.RedimSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_redimSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1498
            self.implicitCallStmt_InStmt()
            self.state = 1500
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1499
                self.match(vbaParser.WS)


            self.state = 1502
            self.match(vbaParser.LPAREN)
            self.state = 1504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1503
                self.match(vbaParser.WS)


            self.state = 1506
            self.subscripts()
            self.state = 1508
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1507
                self.match(vbaParser.WS)


            self.state = 1510
            self.match(vbaParser.RPAREN)
            self.state = 1513
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
            if la_ == 1:
                self.state = 1511
                self.match(vbaParser.WS)
                self.state = 1512
                self.asTypeClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RESET(self):
            return self.getToken(vbaParser.RESET, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_resetStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResetStmt" ):
                listener.enterResetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResetStmt" ):
                listener.exitResetStmt(self)




    def resetStmt(self):

        localctx = vbaParser.ResetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_resetStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1515
            self.match(vbaParser.RESET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResumeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RESUME(self):
            return self.getToken(vbaParser.RESUME, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def NEXT(self):
            return self.getToken(vbaParser.NEXT, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_resumeStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResumeStmt" ):
                listener.enterResumeStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResumeStmt" ):
                listener.exitResumeStmt(self)




    def resumeStmt(self):

        localctx = vbaParser.ResumeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_resumeStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1517
            self.match(vbaParser.RESUME)
            self.state = 1523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.state = 1518
                self.match(vbaParser.WS)
                self.state = 1521
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1519
                    self.match(vbaParser.NEXT)
                    pass

                elif la_ == 2:
                    self.state = 1520
                    self.ambiguousIdentifier()
                    pass




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RETURN(self):
            return self.getToken(vbaParser.RETURN, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_returnStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturnStmt" ):
                listener.enterReturnStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturnStmt" ):
                listener.exitReturnStmt(self)




    def returnStmt(self):

        localctx = vbaParser.ReturnStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_returnStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1525
            self.match(vbaParser.RETURN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RmdirStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RMDIR(self):
            return self.getToken(vbaParser.RMDIR, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_rmdirStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRmdirStmt" ):
                listener.enterRmdirStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRmdirStmt" ):
                listener.exitRmdirStmt(self)




    def rmdirStmt(self):

        localctx = vbaParser.RmdirStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_rmdirStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1527
            self.match(vbaParser.RMDIR)
            self.state = 1528
            self.match(vbaParser.WS)
            self.state = 1529
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RsetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RSET(self):
            return self.getToken(vbaParser.RSET, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_rsetStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRsetStmt" ):
                listener.enterRsetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRsetStmt" ):
                listener.exitRsetStmt(self)




    def rsetStmt(self):

        localctx = vbaParser.RsetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_rsetStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            self.match(vbaParser.RSET)
            self.state = 1532
            self.match(vbaParser.WS)
            self.state = 1533
            self.implicitCallStmt_InStmt()
            self.state = 1535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1534
                self.match(vbaParser.WS)


            self.state = 1537
            self.match(vbaParser.EQ)
            self.state = 1539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1538
                self.match(vbaParser.WS)


            self.state = 1541
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SavepictureStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SAVEPICTURE(self):
            return self.getToken(vbaParser.SAVEPICTURE, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_savepictureStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSavepictureStmt" ):
                listener.enterSavepictureStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSavepictureStmt" ):
                listener.exitSavepictureStmt(self)




    def savepictureStmt(self):

        localctx = vbaParser.SavepictureStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_savepictureStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1543
            self.match(vbaParser.SAVEPICTURE)
            self.state = 1544
            self.match(vbaParser.WS)
            self.state = 1545
            self.valueStmt(0)
            self.state = 1547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1546
                self.match(vbaParser.WS)


            self.state = 1549
            self.match(vbaParser.T__0)
            self.state = 1551
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1550
                self.match(vbaParser.WS)


            self.state = 1553
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SaveSettingStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SAVESETTING(self):
            return self.getToken(vbaParser.SAVESETTING, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_saveSettingStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSaveSettingStmt" ):
                listener.enterSaveSettingStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSaveSettingStmt" ):
                listener.exitSaveSettingStmt(self)




    def saveSettingStmt(self):

        localctx = vbaParser.SaveSettingStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_saveSettingStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1555
            self.match(vbaParser.SAVESETTING)
            self.state = 1556
            self.match(vbaParser.WS)
            self.state = 1557
            self.valueStmt(0)
            self.state = 1559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1558
                self.match(vbaParser.WS)


            self.state = 1561
            self.match(vbaParser.T__0)
            self.state = 1563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1562
                self.match(vbaParser.WS)


            self.state = 1565
            self.valueStmt(0)
            self.state = 1567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1566
                self.match(vbaParser.WS)


            self.state = 1569
            self.match(vbaParser.T__0)
            self.state = 1571
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1570
                self.match(vbaParser.WS)


            self.state = 1573
            self.valueStmt(0)
            self.state = 1575
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==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)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SeekStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SEEK(self):
            return self.getToken(vbaParser.SEEK, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_seekStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSeekStmt" ):
                listener.enterSeekStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSeekStmt" ):
                listener.exitSeekStmt(self)




    def seekStmt(self):

        localctx = vbaParser.SeekStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_seekStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1583
            self.match(vbaParser.SEEK)
            self.state = 1584
            self.match(vbaParser.WS)
            self.state = 1585
            self.fileNumber()
            self.state = 1587
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1586
                self.match(vbaParser.WS)


            self.state = 1589
            self.match(vbaParser.T__0)
            self.state = 1591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1590
                self.match(vbaParser.WS)


            self.state = 1593
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectCaseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SELECT(self):
            return self.getToken(vbaParser.SELECT, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def CASE(self):
            return self.getToken(vbaParser.CASE, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_SELECT(self):
            return self.getToken(vbaParser.END_SELECT, 0)

        def sC_Case(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SC_CaseContext)
            else:
                return self.getTypedRuleContext(vbaParser.SC_CaseContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_selectCaseStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelectCaseStmt" ):
                listener.enterSelectCaseStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelectCaseStmt" ):
                listener.exitSelectCaseStmt(self)




    def selectCaseStmt(self):

        localctx = vbaParser.SelectCaseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_selectCaseStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1595
            self.match(vbaParser.SELECT)
            self.state = 1596
            self.match(vbaParser.WS)
            self.state = 1597
            self.match(vbaParser.CASE)
            self.state = 1598
            self.match(vbaParser.WS)
            self.state = 1599
            self.valueStmt(0)
            self.state = 1600
            self.endOfStatement()
            self.state = 1604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==25:
                self.state = 1601
                self.sC_Case()
                self.state = 1606
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1607
            self.match(vbaParser.END_SELECT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SC_SelectionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Selection

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class CaseCondValueContext(SC_SelectionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a vbaParser.SC_SelectionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseCondValue" ):
                listener.enterCaseCondValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseCondValue" ):
                listener.exitCaseCondValue(self)


    class CaseCondToContext(SC_SelectionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a vbaParser.SC_SelectionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)
        def TO(self):
            return self.getToken(vbaParser.TO, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseCondTo" ):
                listener.enterCaseCondTo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseCondTo" ):
                listener.exitCaseCondTo(self)


    class CaseCondIsContext(SC_SelectionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a vbaParser.SC_SelectionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IS(self):
            return self.getToken(vbaParser.IS, 0)
        def comparisonOperator(self):
            return self.getTypedRuleContext(vbaParser.ComparisonOperatorContext,0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseCondIs" ):
                listener.enterCaseCondIs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseCondIs" ):
                listener.exitCaseCondIs(self)



    def sC_Selection(self):

        localctx = vbaParser.SC_SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_sC_Selection)
        self._la = 0 # Token type
        try:
            self.state = 1626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,229,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondIsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1609
                self.match(vbaParser.IS)
                self.state = 1611
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1610
                    self.match(vbaParser.WS)


                self.state = 1613
                self.comparisonOperator()
                self.state = 1615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1614
                    self.match(vbaParser.WS)


                self.state = 1617
                self.valueStmt(0)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondToContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1619
                self.valueStmt(0)
                self.state = 1620
                self.match(vbaParser.WS)
                self.state = 1621
                self.match(vbaParser.TO)
                self.state = 1622
                self.match(vbaParser.WS)
                self.state = 1623
                self.valueStmt(0)
                pass

            elif la_ == 3:
                localctx = vbaParser.CaseCondValueContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1625
                self.valueStmt(0)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SC_CaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CASE(self):
            return self.getToken(vbaParser.CASE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def sC_Cond(self):
            return self.getTypedRuleContext(vbaParser.SC_CondContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Case

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSC_Case" ):
                listener.enterSC_Case(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSC_Case" ):
                listener.exitSC_Case(self)




    def sC_Case(self):

        localctx = vbaParser.SC_CaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_sC_Case)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1628
            self.match(vbaParser.CASE)
            self.state = 1629
            self.match(vbaParser.WS)
            self.state = 1630
            self.sC_Cond()
            self.state = 1631
            self.endOfStatement()
            self.state = 1633
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.state = 1632
                self.block()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SC_CondContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return vbaParser.RULE_sC_Cond

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class CaseCondSelectionContext(SC_CondContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a vbaParser.SC_CondContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def sC_Selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SC_SelectionContext)
            else:
                return self.getTypedRuleContext(vbaParser.SC_SelectionContext,i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseCondSelection" ):
                listener.enterCaseCondSelection(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseCondSelection" ):
                listener.exitCaseCondSelection(self)


    class CaseCondElseContext(SC_CondContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a vbaParser.SC_CondContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ELSE(self):
            return self.getToken(vbaParser.ELSE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseCondElse" ):
                listener.enterCaseCondElse(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseCondElse" ):
                listener.exitCaseCondElse(self)



    def sC_Cond(self):

        localctx = vbaParser.SC_CondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_sC_Cond)
        self._la = 0 # Token type
        try:
            self.state = 1650
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                localctx = vbaParser.CaseCondElseContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1635
                self.match(vbaParser.ELSE)
                pass

            elif la_ == 2:
                localctx = vbaParser.CaseCondSelectionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1636
                self.sC_Selection()
                self.state = 1647
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,233,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1638
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1637
                            self.match(vbaParser.WS)


                        self.state = 1640
                        self.match(vbaParser.T__0)
                        self.state = 1642
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1641
                            self.match(vbaParser.WS)


                        self.state = 1644
                        self.sC_Selection() 
                    self.state = 1649
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,233,self._ctx)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SendkeysStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SENDKEYS(self):
            return self.getToken(vbaParser.SENDKEYS, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_sendkeysStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSendkeysStmt" ):
                listener.enterSendkeysStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSendkeysStmt" ):
                listener.exitSendkeysStmt(self)




    def sendkeysStmt(self):

        localctx = vbaParser.SendkeysStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_sendkeysStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1652
            self.match(vbaParser.SENDKEYS)
            self.state = 1653
            self.match(vbaParser.WS)
            self.state = 1654
            self.valueStmt(0)
            self.state = 1663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
            if la_ == 1:
                self.state = 1656
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1655
                    self.match(vbaParser.WS)


                self.state = 1658
                self.match(vbaParser.T__0)
                self.state = 1660
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1659
                    self.match(vbaParser.WS)


                self.state = 1662
                self.valueStmt(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetattrStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SETATTR(self):
            return self.getToken(vbaParser.SETATTR, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_setattrStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetattrStmt" ):
                listener.enterSetattrStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetattrStmt" ):
                listener.exitSetattrStmt(self)




    def setattrStmt(self):

        localctx = vbaParser.SetattrStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_setattrStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1665
            self.match(vbaParser.SETATTR)
            self.state = 1666
            self.match(vbaParser.WS)
            self.state = 1667
            self.valueStmt(0)
            self.state = 1669
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1668
                self.match(vbaParser.WS)


            self.state = 1671
            self.match(vbaParser.T__0)
            self.state = 1673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1672
                self.match(vbaParser.WS)


            self.state = 1675
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SET(self):
            return self.getToken(vbaParser.SET, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_setStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSetStmt" ):
                listener.enterSetStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSetStmt" ):
                listener.exitSetStmt(self)




    def setStmt(self):

        localctx = vbaParser.SetStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_setStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1677
            self.match(vbaParser.SET)
            self.state = 1678
            self.match(vbaParser.WS)
            self.state = 1679
            self.implicitCallStmt_InStmt()
            self.state = 1681
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1680
                self.match(vbaParser.WS)


            self.state = 1683
            self.match(vbaParser.EQ)
            self.state = 1685
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1684
                self.match(vbaParser.WS)


            self.state = 1687
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StopStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STOP(self):
            return self.getToken(vbaParser.STOP, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_stopStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStopStmt" ):
                listener.enterStopStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStopStmt" ):
                listener.exitStopStmt(self)




    def stopStmt(self):

        localctx = vbaParser.StopStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_stopStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1689
            self.match(vbaParser.STOP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SUB(self):
            return self.getToken(vbaParser.SUB, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_SUB(self):
            return self.getToken(vbaParser.END_SUB, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def argList(self):
            return self.getTypedRuleContext(vbaParser.ArgListContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_subStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubStmt" ):
                listener.enterSubStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubStmt" ):
                listener.exitSubStmt(self)




    def subStmt(self):

        localctx = vbaParser.SubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_subStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1694
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1691
                self.visibility()
                self.state = 1692
                self.match(vbaParser.WS)


            self.state = 1698
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1696
                self.match(vbaParser.STATIC)
                self.state = 1697
                self.match(vbaParser.WS)


            self.state = 1700
            self.match(vbaParser.SUB)
            self.state = 1702
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1701
                self.match(vbaParser.WS)


            self.state = 1704
            self.ambiguousIdentifier()
            self.state = 1709
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,246,self._ctx)
            if la_ == 1:
                self.state = 1706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1705
                    self.match(vbaParser.WS)


                self.state = 1708
                self.argList()


            self.state = 1711
            self.endOfStatement()
            self.state = 1713
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -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==212 or _la==220:
                self.state = 1712
                self.block()


            self.state = 1715
            self.match(vbaParser.END_SUB)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TimeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TIME(self):
            return self.getToken(vbaParser.TIME, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_timeStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimeStmt" ):
                listener.enterTimeStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimeStmt" ):
                listener.exitTimeStmt(self)




    def timeStmt(self):

        localctx = vbaParser.TimeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_timeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1717
            self.match(vbaParser.TIME)
            self.state = 1719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1718
                self.match(vbaParser.WS)


            self.state = 1721
            self.match(vbaParser.EQ)
            self.state = 1723
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1722
                self.match(vbaParser.WS)


            self.state = 1725
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TYPE(self):
            return self.getToken(vbaParser.TYPE, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_TYPE(self):
            return self.getToken(vbaParser.END_TYPE, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def typeStmt_Element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.TypeStmt_ElementContext)
            else:
                return self.getTypedRuleContext(vbaParser.TypeStmt_ElementContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_typeStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeStmt" ):
                listener.enterTypeStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeStmt" ):
                listener.exitTypeStmt(self)




    def typeStmt(self):

        localctx = vbaParser.TypeStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_typeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 4755801206503243793) != 0):
                self.state = 1727
                self.visibility()
                self.state = 1728
                self.match(vbaParser.WS)


            self.state = 1732
            self.match(vbaParser.TYPE)
            self.state = 1733
            self.match(vbaParser.WS)
            self.state = 1734
            self.ambiguousIdentifier()
            self.state = 1735
            self.endOfStatement()
            self.state = 1739
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -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 = 1736
                self.typeStmt_Element()
                self.state = 1741
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1742
            self.match(vbaParser.END_TYPE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeStmt_ElementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_typeStmt_Element

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeStmt_Element" ):
                listener.enterTypeStmt_Element(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeStmt_Element" ):
                listener.exitTypeStmt_Element(self)




    def typeStmt_Element(self):

        localctx = vbaParser.TypeStmt_ElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_typeStmt_Element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1744
            self.ambiguousIdentifier()
            self.state = 1759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.state = 1746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1745
                    self.match(vbaParser.WS)


                self.state = 1748
                self.match(vbaParser.LPAREN)
                self.state = 1753
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,254,self._ctx)
                if la_ == 1:
                    self.state = 1750
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1749
                        self.match(vbaParser.WS)


                    self.state = 1752
                    self.subscripts()


                self.state = 1756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1755
                    self.match(vbaParser.WS)


                self.state = 1758
                self.match(vbaParser.RPAREN)


            self.state = 1763
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,257,self._ctx)
            if la_ == 1:
                self.state = 1761
                self.match(vbaParser.WS)
                self.state = 1762
                self.asTypeClause()


            self.state = 1765
            self.endOfStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeOfStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TYPEOF(self):
            return self.getToken(vbaParser.TYPEOF, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def IS(self):
            return self.getToken(vbaParser.IS, 0)

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


        def getRuleIndex(self):
            return vbaParser.RULE_typeOfStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeOfStmt" ):
                listener.enterTypeOfStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeOfStmt" ):
                listener.exitTypeOfStmt(self)




    def typeOfStmt(self):

        localctx = vbaParser.TypeOfStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_typeOfStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1767
            self.match(vbaParser.TYPEOF)
            self.state = 1768
            self.match(vbaParser.WS)
            self.state = 1769
            self.valueStmt(0)
            self.state = 1774
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.state = 1770
                self.match(vbaParser.WS)
                self.state = 1771
                self.match(vbaParser.IS)
                self.state = 1772
                self.match(vbaParser.WS)
                self.state = 1773
                self.type_()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnloadStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UNLOAD(self):
            return self.getToken(vbaParser.UNLOAD, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_unloadStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnloadStmt" ):
                listener.enterUnloadStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnloadStmt" ):
                listener.exitUnloadStmt(self)




    def unloadStmt(self):

        localctx = vbaParser.UnloadStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_unloadStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1776
            self.match(vbaParser.UNLOAD)
            self.state = 1777
            self.match(vbaParser.WS)
            self.state = 1778
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnlockStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UNLOCK(self):
            return self.getToken(vbaParser.UNLOCK, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def TO(self):
            return self.getToken(vbaParser.TO, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_unlockStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnlockStmt" ):
                listener.enterUnlockStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnlockStmt" ):
                listener.exitUnlockStmt(self)




    def unlockStmt(self):

        localctx = vbaParser.UnlockStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_unlockStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1780
            self.match(vbaParser.UNLOCK)
            self.state = 1781
            self.match(vbaParser.WS)
            self.state = 1782
            self.fileNumber()
            self.state = 1797
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.state = 1784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1783
                    self.match(vbaParser.WS)


                self.state = 1786
                self.match(vbaParser.T__0)
                self.state = 1788
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1787
                    self.match(vbaParser.WS)


                self.state = 1790
                self.valueStmt(0)
                self.state = 1795
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1791
                    self.match(vbaParser.WS)
                    self.state = 1792
                    self.match(vbaParser.TO)
                    self.state = 1793
                    self.match(vbaParser.WS)
                    self.state = 1794
                    self.valueStmt(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ValueStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return vbaParser.RULE_valueStmt

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class 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 = 200
        self.enterRecursionRule(localctx, 200, self.RULE_valueStmt, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1859
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                localctx = vbaParser.VsLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1800
                self.literal()
                pass

            elif la_ == 2:
                localctx = vbaParser.VsICSContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1801
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 3:
                localctx = vbaParser.VsStructContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1802
                self.match(vbaParser.LPAREN)
                self.state = 1804
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1803
                    self.match(vbaParser.WS)


                self.state = 1806
                self.valueStmt(0)
                self.state = 1817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==1 or _la==219:
                    self.state = 1808
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1807
                        self.match(vbaParser.WS)


                    self.state = 1810
                    self.match(vbaParser.T__0)
                    self.state = 1812
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1811
                        self.match(vbaParser.WS)


                    self.state = 1814
                    self.valueStmt(0)
                    self.state = 1819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1820
                self.match(vbaParser.RPAREN)
                pass

            elif la_ == 4:
                localctx = vbaParser.VsNewContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1822
                self.match(vbaParser.NEW)
                self.state = 1824
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1823
                    self.match(vbaParser.WS)


                self.state = 1826
                self.valueStmt(19)
                pass

            elif la_ == 5:
                localctx = vbaParser.VsTypeOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1827
                self.typeOfStmt()
                pass

            elif la_ == 6:
                localctx = vbaParser.VsMidContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1828
                self.midStmt()
                pass

            elif la_ == 7:
                localctx = vbaParser.VsAddressOfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1829
                self.match(vbaParser.ADDRESSOF)
                self.state = 1831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1830
                    self.match(vbaParser.WS)


                self.state = 1833
                self.valueStmt(16)
                pass

            elif la_ == 8:
                localctx = vbaParser.VsAssignContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1834
                self.implicitCallStmt_InStmt()
                self.state = 1836
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1835
                    self.match(vbaParser.WS)


                self.state = 1838
                self.match(vbaParser.ASSIGN)
                self.state = 1840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1839
                    self.match(vbaParser.WS)


                self.state = 1842
                self.valueStmt(15)
                pass

            elif la_ == 9:
                localctx = vbaParser.VsNegationContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1844
                self.match(vbaParser.MINUS)
                self.state = 1846
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1845
                    self.match(vbaParser.WS)


                self.state = 1848
                self.valueStmt(13)
                pass

            elif la_ == 10:
                localctx = vbaParser.VsPlusContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1849
                self.match(vbaParser.PLUS)
                self.state = 1851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1850
                    self.match(vbaParser.WS)


                self.state = 1853
                self.valueStmt(12)
                pass

            elif la_ == 11:
                localctx = vbaParser.VsNotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1854
                self.match(vbaParser.NOT)
                self.state = 1856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1855
                    self.match(vbaParser.WS)


                self.state = 1858
                self.valueStmt(6)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1962
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,298,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 = 1960
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,297,self._ctx)
                    if la_ == 1:
                        localctx = vbaParser.VsPowContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1861
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1863
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1862
                            self.match(vbaParser.WS)


                        self.state = 1865
                        self.match(vbaParser.POW)
                        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(15)
                        pass

                    elif la_ == 2:
                        localctx = vbaParser.VsDivMultContext(self, vbaParser.ValueStmtContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_valueStmt)
                        self.state = 1870
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        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
                        _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 = 1876
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1875
                            self.match(vbaParser.WS)


                        self.state = 1878
                        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 = 1879
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1881
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1880
                            self.match(vbaParser.WS)


                        self.state = 1883
                        self.match(vbaParser.MOD)
                        self.state = 1885
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1884
                            self.match(vbaParser.WS)


                        self.state = 1887
                        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 = 1888
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1890
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1889
                            self.match(vbaParser.WS)


                        self.state = 1892
                        _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 = 1894
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1893
                            self.match(vbaParser.WS)


                        self.state = 1896
                        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 = 1897
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1899
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1898
                            self.match(vbaParser.WS)


                        self.state = 1901
                        self.match(vbaParser.AMPERSAND)
                        self.state = 1903
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1902
                            self.match(vbaParser.WS)


                        self.state = 1905
                        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 = 1906
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1908
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1907
                            self.match(vbaParser.WS)


                        self.state = 1910
                        _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 = 1912
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1911
                            self.match(vbaParser.WS)


                        self.state = 1914
                        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 = 1915
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1917
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1916
                            self.match(vbaParser.WS)


                        self.state = 1919
                        self.match(vbaParser.AND)
                        self.state = 1921
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1920
                            self.match(vbaParser.WS)


                        self.state = 1923
                        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 = 1924
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1926
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1925
                            self.match(vbaParser.WS)


                        self.state = 1928
                        self.match(vbaParser.OR)
                        self.state = 1930
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1929
                            self.match(vbaParser.WS)


                        self.state = 1932
                        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 = 1933
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1935
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1934
                            self.match(vbaParser.WS)


                        self.state = 1937
                        self.match(vbaParser.XOR)
                        self.state = 1939
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1938
                            self.match(vbaParser.WS)


                        self.state = 1941
                        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 = 1942
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1944
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1943
                            self.match(vbaParser.WS)


                        self.state = 1946
                        self.match(vbaParser.EQV)
                        self.state = 1948
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1947
                            self.match(vbaParser.WS)


                        self.state = 1950
                        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 = 1951
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1953
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1952
                            self.match(vbaParser.WS)


                        self.state = 1955
                        self.match(vbaParser.IMP)
                        self.state = 1957
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 1956
                            self.match(vbaParser.WS)


                        self.state = 1959
                        self.valueStmt(2)
                        pass

             
                self.state = 1964
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,298,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class VariableStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def variableListStmt(self):
            return self.getTypedRuleContext(vbaParser.VariableListStmtContext,0)


        def DIM(self):
            return self.getToken(vbaParser.DIM, 0)

        def STATIC(self):
            return self.getToken(vbaParser.STATIC, 0)

        def visibility(self):
            return self.getTypedRuleContext(vbaParser.VisibilityContext,0)


        def WITHEVENTS(self):
            return self.getToken(vbaParser.WITHEVENTS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_variableStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableStmt" ):
                listener.enterVariableStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableStmt" ):
                listener.exitVariableStmt(self)




    def variableStmt(self):

        localctx = vbaParser.VariableStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_variableStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1968
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48]:
                self.state = 1965
                self.match(vbaParser.DIM)
                pass
            elif token in [161]:
                self.state = 1966
                self.match(vbaParser.STATIC)
                pass
            elif token in [75, 79, 132, 137]:
                self.state = 1967
                self.visibility()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1970
            self.match(vbaParser.WS)
            self.state = 1973
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,300,self._ctx)
            if la_ == 1:
                self.state = 1971
                self.match(vbaParser.WITHEVENTS)
                self.state = 1972
                self.match(vbaParser.WS)


            self.state = 1975
            self.variableListStmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableListStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableSubStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.VariableSubStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.VariableSubStmtContext,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_variableListStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableListStmt" ):
                listener.enterVariableListStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableListStmt" ):
                listener.exitVariableListStmt(self)




    def variableListStmt(self):

        localctx = vbaParser.VariableListStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_variableListStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1977
            self.variableSubStmt()
            self.state = 1988
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,303,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1979
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1978
                        self.match(vbaParser.WS)


                    self.state = 1981
                    self.match(vbaParser.T__0)
                    self.state = 1983
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 1982
                        self.match(vbaParser.WS)


                    self.state = 1985
                    self.variableSubStmt() 
                self.state = 1990
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,303,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableSubStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def subscripts(self):
            return self.getTypedRuleContext(vbaParser.SubscriptsContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_variableSubStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariableSubStmt" ):
                listener.enterVariableSubStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariableSubStmt" ):
                listener.exitVariableSubStmt(self)




    def variableSubStmt(self):

        localctx = vbaParser.VariableSubStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_variableSubStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1991
            self.ambiguousIdentifier()
            self.state = 2009
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,309,self._ctx)
            if la_ == 1:
                self.state = 1993
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1992
                    self.match(vbaParser.WS)


                self.state = 1995
                self.match(vbaParser.LPAREN)
                self.state = 1997
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1996
                    self.match(vbaParser.WS)


                self.state = 2003
                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 = 1999
                    self.subscripts()
                    self.state = 2001
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2000
                        self.match(vbaParser.WS)




                self.state = 2005
                self.match(vbaParser.RPAREN)
                self.state = 2007
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,308,self._ctx)
                if la_ == 1:
                    self.state = 2006
                    self.match(vbaParser.WS)




            self.state = 2012
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,310,self._ctx)
            if la_ == 1:
                self.state = 2011
                self.typeHint()


            self.state = 2016
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,311,self._ctx)
            if la_ == 1:
                self.state = 2014
                self.match(vbaParser.WS)
                self.state = 2015
                self.asTypeClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhileWendStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHILE(self):
            return self.getToken(vbaParser.WHILE, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def WEND(self):
            return self.getToken(vbaParser.WEND, 0)

        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_whileWendStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhileWendStmt" ):
                listener.enterWhileWendStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhileWendStmt" ):
                listener.exitWhileWendStmt(self)




    def whileWendStmt(self):

        localctx = vbaParser.WhileWendStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_whileWendStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.match(vbaParser.WHILE)
            self.state = 2019
            self.match(vbaParser.WS)
            self.state = 2020
            self.valueStmt(0)
            self.state = 2021
            self.endOfStatement()
            self.state = 2023
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,312,self._ctx)
            if la_ == 1:
                self.state = 2022
                self.block()


            self.state = 2025
            self.match(vbaParser.WEND)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WidthStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WIDTH(self):
            return self.getToken(vbaParser.WIDTH, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_widthStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWidthStmt" ):
                listener.enterWidthStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWidthStmt" ):
                listener.exitWidthStmt(self)




    def widthStmt(self):

        localctx = vbaParser.WidthStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_widthStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2027
            self.match(vbaParser.WIDTH)
            self.state = 2028
            self.match(vbaParser.WS)
            self.state = 2029
            self.fileNumber()
            self.state = 2031
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2030
                self.match(vbaParser.WS)


            self.state = 2033
            self.match(vbaParser.T__0)
            self.state = 2035
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2034
                self.match(vbaParser.WS)


            self.state = 2037
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WithStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITH(self):
            return self.getToken(vbaParser.WITH, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def endOfStatement(self):
            return self.getTypedRuleContext(vbaParser.EndOfStatementContext,0)


        def END_WITH(self):
            return self.getToken(vbaParser.END_WITH, 0)

        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def block(self):
            return self.getTypedRuleContext(vbaParser.BlockContext,0)


        def NEW(self):
            return self.getToken(vbaParser.NEW, 0)

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


        def getRuleIndex(self):
            return vbaParser.RULE_withStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWithStmt" ):
                listener.enterWithStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWithStmt" ):
                listener.exitWithStmt(self)




    def withStmt(self):

        localctx = vbaParser.WithStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_withStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2039
            self.match(vbaParser.WITH)
            self.state = 2040
            self.match(vbaParser.WS)
            self.state = 2045
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,315,self._ctx)
            if la_ == 1:
                self.state = 2041
                self.implicitCallStmt_InStmt()
                pass

            elif la_ == 2:
                self.state = 2042
                self.match(vbaParser.NEW)
                self.state = 2043
                self.match(vbaParser.WS)
                self.state = 2044
                self.type_()
                pass


            self.state = 2047
            self.endOfStatement()
            self.state = 2049
            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==212 or _la==220:
                self.state = 2048
                self.block()


            self.state = 2051
            self.match(vbaParser.END_WITH)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WriteStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WRITE(self):
            return self.getToken(vbaParser.WRITE, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def fileNumber(self):
            return self.getTypedRuleContext(vbaParser.FileNumberContext,0)


        def outputList(self):
            return self.getTypedRuleContext(vbaParser.OutputListContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_writeStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWriteStmt" ):
                listener.enterWriteStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWriteStmt" ):
                listener.exitWriteStmt(self)




    def writeStmt(self):

        localctx = vbaParser.WriteStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_writeStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2053
            self.match(vbaParser.WRITE)
            self.state = 2054
            self.match(vbaParser.WS)
            self.state = 2055
            self.fileNumber()
            self.state = 2057
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2056
                self.match(vbaParser.WS)


            self.state = 2059
            self.match(vbaParser.T__0)
            self.state = 2064
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
            if la_ == 1:
                self.state = 2061
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,318,self._ctx)
                if la_ == 1:
                    self.state = 2060
                    self.match(vbaParser.WS)


                self.state = 2063
                self.outputList()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FileNumberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_fileNumber

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFileNumber" ):
                listener.enterFileNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFileNumber" ):
                listener.exitFileNumber(self)




    def fileNumber(self):

        localctx = vbaParser.FileNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_fileNumber)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2067
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==3:
                self.state = 2066
                self.match(vbaParser.T__2)


            self.state = 2069
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplicitCallStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eCS_ProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ECS_ProcedureCallContext,0)


        def eCS_MemberProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ECS_MemberProcedureCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_explicitCallStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitCallStmt" ):
                listener.enterExplicitCallStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitCallStmt" ):
                listener.exitExplicitCallStmt(self)




    def explicitCallStmt(self):

        localctx = vbaParser.ExplicitCallStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_explicitCallStmt)
        try:
            self.state = 2073
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,321,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2071
                self.eCS_ProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2072
                self.eCS_MemberProcedureCall()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ECS_ProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CALL(self):
            return self.getToken(vbaParser.CALL, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_eCS_ProcedureCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterECS_ProcedureCall" ):
                listener.enterECS_ProcedureCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitECS_ProcedureCall" ):
                listener.exitECS_ProcedureCall(self)




    def eCS_ProcedureCall(self):

        localctx = vbaParser.ECS_ProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_eCS_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2075
            self.match(vbaParser.CALL)
            self.state = 2076
            self.match(vbaParser.WS)
            self.state = 2077
            self.ambiguousIdentifier()
            self.state = 2079
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,322,self._ctx)
            if la_ == 1:
                self.state = 2078
                self.typeHint()


            self.state = 2094
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,326,self._ctx)
            if la_ == 1:
                self.state = 2082
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2081
                    self.match(vbaParser.WS)


                self.state = 2084
                self.match(vbaParser.LPAREN)
                self.state = 2086
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,324,self._ctx)
                if la_ == 1:
                    self.state = 2085
                    self.match(vbaParser.WS)


                self.state = 2088
                self.argsCall()
                self.state = 2090
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2089
                    self.match(vbaParser.WS)


                self.state = 2092
                self.match(vbaParser.RPAREN)


            self.state = 2105
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,328,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2097
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2096
                        self.match(vbaParser.WS)


                    self.state = 2099
                    self.match(vbaParser.LPAREN)
                    self.state = 2100
                    self.subscripts()
                    self.state = 2101
                    self.match(vbaParser.RPAREN) 
                self.state = 2107
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,328,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ECS_MemberProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CALL(self):
            return self.getToken(vbaParser.CALL, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_eCS_MemberProcedureCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterECS_MemberProcedureCall" ):
                listener.enterECS_MemberProcedureCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitECS_MemberProcedureCall" ):
                listener.exitECS_MemberProcedureCall(self)




    def eCS_MemberProcedureCall(self):

        localctx = vbaParser.ECS_MemberProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_eCS_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2108
            self.match(vbaParser.CALL)
            self.state = 2109
            self.match(vbaParser.WS)
            self.state = 2111
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,329,self._ctx)
            if la_ == 1:
                self.state = 2110
                self.implicitCallStmt_InStmt()


            self.state = 2113
            self.match(vbaParser.T__3)
            self.state = 2114
            self.ambiguousIdentifier()
            self.state = 2116
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
            if la_ == 1:
                self.state = 2115
                self.typeHint()


            self.state = 2131
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,334,self._ctx)
            if la_ == 1:
                self.state = 2119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2118
                    self.match(vbaParser.WS)


                self.state = 2121
                self.match(vbaParser.LPAREN)
                self.state = 2123
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,332,self._ctx)
                if la_ == 1:
                    self.state = 2122
                    self.match(vbaParser.WS)


                self.state = 2125
                self.argsCall()
                self.state = 2127
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2126
                    self.match(vbaParser.WS)


                self.state = 2129
                self.match(vbaParser.RPAREN)


            self.state = 2142
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,336,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2134
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2133
                        self.match(vbaParser.WS)


                    self.state = 2136
                    self.match(vbaParser.LPAREN)
                    self.state = 2137
                    self.subscripts()
                    self.state = 2138
                    self.match(vbaParser.RPAREN) 
                self.state = 2144
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,336,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImplicitCallStmt_InBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def iCS_B_MemberProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_B_MemberProcedureCallContext,0)


        def iCS_B_ProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_B_ProcedureCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_implicitCallStmt_InBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImplicitCallStmt_InBlock" ):
                listener.enterImplicitCallStmt_InBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImplicitCallStmt_InBlock" ):
                listener.exitImplicitCallStmt_InBlock(self)




    def implicitCallStmt_InBlock(self):

        localctx = vbaParser.ImplicitCallStmt_InBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_implicitCallStmt_InBlock)
        try:
            self.state = 2147
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2145
                self.iCS_B_MemberProcedureCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2146
                self.iCS_B_ProcedureCall()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_B_MemberProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def implicitCallStmt_InStmt(self):
            return self.getTypedRuleContext(vbaParser.ImplicitCallStmt_InStmtContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_B_MemberProcedureCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_B_MemberProcedureCall" ):
                listener.enterICS_B_MemberProcedureCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_B_MemberProcedureCall" ):
                listener.exitICS_B_MemberProcedureCall(self)




    def iCS_B_MemberProcedureCall(self):

        localctx = vbaParser.ICS_B_MemberProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_iCS_B_MemberProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2150
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                self.state = 2149
                self.implicitCallStmt_InStmt()


            self.state = 2152
            self.match(vbaParser.T__3)
            self.state = 2153
            self.ambiguousIdentifier()
            self.state = 2155
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,339,self._ctx)
            if la_ == 1:
                self.state = 2154
                self.typeHint()


            self.state = 2159
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,340,self._ctx)
            if la_ == 1:
                self.state = 2157
                self.match(vbaParser.WS)
                self.state = 2158
                self.argsCall()


            self.state = 2162
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,341,self._ctx)
            if la_ == 1:
                self.state = 2161
                self.dictionaryCallStmt()


            self.state = 2173
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,343,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2165
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2164
                        self.match(vbaParser.WS)


                    self.state = 2167
                    self.match(vbaParser.LPAREN)
                    self.state = 2168
                    self.subscripts()
                    self.state = 2169
                    self.match(vbaParser.RPAREN) 
                self.state = 2175
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,343,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_B_ProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def certainIdentifier(self):
            return self.getTypedRuleContext(vbaParser.CertainIdentifierContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_B_ProcedureCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_B_ProcedureCall" ):
                listener.enterICS_B_ProcedureCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_B_ProcedureCall" ):
                listener.exitICS_B_ProcedureCall(self)




    def iCS_B_ProcedureCall(self):

        localctx = vbaParser.ICS_B_ProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_iCS_B_ProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2176
            self.certainIdentifier()
            self.state = 2179
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,344,self._ctx)
            if la_ == 1:
                self.state = 2177
                self.match(vbaParser.WS)
                self.state = 2178
                self.argsCall()


            self.state = 2190
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,346,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2182
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2181
                        self.match(vbaParser.WS)


                    self.state = 2184
                    self.match(vbaParser.LPAREN)
                    self.state = 2185
                    self.subscripts()
                    self.state = 2186
                    self.match(vbaParser.RPAREN) 
                self.state = 2192
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,346,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImplicitCallStmt_InStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def iCS_S_MembersCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_MembersCallContext,0)


        def iCS_S_VariableOrProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_VariableOrProcedureCallContext,0)


        def iCS_S_ProcedureOrArrayCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_ProcedureOrArrayCallContext,0)


        def iCS_S_DictionaryCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_DictionaryCallContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_implicitCallStmt_InStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImplicitCallStmt_InStmt" ):
                listener.enterImplicitCallStmt_InStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImplicitCallStmt_InStmt" ):
                listener.exitImplicitCallStmt_InStmt(self)




    def implicitCallStmt_InStmt(self):

        localctx = vbaParser.ImplicitCallStmt_InStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_implicitCallStmt_InStmt)
        try:
            self.state = 2197
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,347,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2193
                self.iCS_S_MembersCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2194
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2195
                self.iCS_S_ProcedureOrArrayCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2196
                self.iCS_S_DictionaryCall()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_S_VariableOrProcedureCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_VariableOrProcedureCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_S_VariableOrProcedureCall" ):
                listener.enterICS_S_VariableOrProcedureCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_S_VariableOrProcedureCall" ):
                listener.exitICS_S_VariableOrProcedureCall(self)




    def iCS_S_VariableOrProcedureCall(self):

        localctx = vbaParser.ICS_S_VariableOrProcedureCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_iCS_S_VariableOrProcedureCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2199
            self.ambiguousIdentifier()
            self.state = 2201
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,348,self._ctx)
            if la_ == 1:
                self.state = 2200
                self.typeHint()


            self.state = 2204
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,349,self._ctx)
            if la_ == 1:
                self.state = 2203
                self.dictionaryCallStmt()


            self.state = 2215
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,351,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2207
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2206
                        self.match(vbaParser.WS)


                    self.state = 2209
                    self.match(vbaParser.LPAREN)
                    self.state = 2210
                    self.subscripts()
                    self.state = 2211
                    self.match(vbaParser.RPAREN) 
                self.state = 2217
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,351,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_S_ProcedureOrArrayCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def baseType(self):
            return self.getTypedRuleContext(vbaParser.BaseTypeContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def argsCall(self):
            return self.getTypedRuleContext(vbaParser.ArgsCallContext,0)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_ProcedureOrArrayCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_S_ProcedureOrArrayCall" ):
                listener.enterICS_S_ProcedureOrArrayCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_S_ProcedureOrArrayCall" ):
                listener.exitICS_S_ProcedureOrArrayCall(self)




    def iCS_S_ProcedureOrArrayCall(self):

        localctx = vbaParser.ICS_S_ProcedureOrArrayCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_iCS_S_ProcedureOrArrayCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2220
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,352,self._ctx)
            if la_ == 1:
                self.state = 2218
                self.ambiguousIdentifier()
                pass

            elif la_ == 2:
                self.state = 2219
                self.baseType()
                pass


            self.state = 2223
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 2222
                self.typeHint()


            self.state = 2226
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2225
                self.match(vbaParser.WS)


            self.state = 2228
            self.match(vbaParser.LPAREN)
            self.state = 2230
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,355,self._ctx)
            if la_ == 1:
                self.state = 2229
                self.match(vbaParser.WS)


            self.state = 2236
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,357,self._ctx)
            if la_ == 1:
                self.state = 2232
                self.argsCall()
                self.state = 2234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2233
                    self.match(vbaParser.WS)




            self.state = 2238
            self.match(vbaParser.RPAREN)
            self.state = 2240
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,358,self._ctx)
            if la_ == 1:
                self.state = 2239
                self.dictionaryCallStmt()


            self.state = 2251
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,360,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2243
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2242
                        self.match(vbaParser.WS)


                    self.state = 2245
                    self.match(vbaParser.LPAREN)
                    self.state = 2246
                    self.subscripts()
                    self.state = 2247
                    self.match(vbaParser.RPAREN) 
                self.state = 2253
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,360,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_S_MembersCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def iCS_S_VariableOrProcedureCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_VariableOrProcedureCallContext,0)


        def iCS_S_ProcedureOrArrayCall(self):
            return self.getTypedRuleContext(vbaParser.ICS_S_ProcedureOrArrayCallContext,0)


        def iCS_S_MemberCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ICS_S_MemberCallContext)
            else:
                return self.getTypedRuleContext(vbaParser.ICS_S_MemberCallContext,i)


        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.LPAREN)
            else:
                return self.getToken(vbaParser.LPAREN, i)

        def subscripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.SubscriptsContext)
            else:
                return self.getTypedRuleContext(vbaParser.SubscriptsContext,i)


        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.RPAREN)
            else:
                return self.getToken(vbaParser.RPAREN, i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_MembersCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_S_MembersCall" ):
                listener.enterICS_S_MembersCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_S_MembersCall" ):
                listener.exitICS_S_MembersCall(self)




    def iCS_S_MembersCall(self):

        localctx = vbaParser.ICS_S_MembersCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_iCS_S_MembersCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2256
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,361,self._ctx)
            if la_ == 1:
                self.state = 2254
                self.iCS_S_VariableOrProcedureCall()

            elif la_ == 2:
                self.state = 2255
                self.iCS_S_ProcedureOrArrayCall()


            self.state = 2259 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2258
                    self.iCS_S_MemberCall()

                else:
                    raise NoViableAltException(self)
                self.state = 2261 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,362,self._ctx)

            self.state = 2264
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,363,self._ctx)
            if la_ == 1:
                self.state = 2263
                self.dictionaryCallStmt()


            self.state = 2275
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,365,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2267
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2266
                        self.match(vbaParser.WS)


                    self.state = 2269
                    self.match(vbaParser.LPAREN)
                    self.state = 2270
                    self.subscripts()
                    self.state = 2271
                    self.match(vbaParser.RPAREN) 
                self.state = 2277
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,365,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, 238, self.RULE_iCS_S_MemberCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2279
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 2278
                self.match(vbaParser.LINE_CONTINUATION)


            self.state = 2281
            _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 = 2283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 2282
                self.match(vbaParser.LINE_CONTINUATION)


            self.state = 2287
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,368,self._ctx)
            if la_ == 1:
                self.state = 2285
                self.iCS_S_VariableOrProcedureCall()
                pass

            elif la_ == 2:
                self.state = 2286
                self.iCS_S_ProcedureOrArrayCall()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ICS_S_DictionaryCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dictionaryCallStmt(self):
            return self.getTypedRuleContext(vbaParser.DictionaryCallStmtContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_iCS_S_DictionaryCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterICS_S_DictionaryCall" ):
                listener.enterICS_S_DictionaryCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitICS_S_DictionaryCall" ):
                listener.exitICS_S_DictionaryCall(self)




    def iCS_S_DictionaryCall(self):

        localctx = vbaParser.ICS_S_DictionaryCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_iCS_S_DictionaryCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2289
            self.dictionaryCallStmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgsCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ArgCallContext)
            else:
                return self.getTypedRuleContext(vbaParser.ArgCallContext,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_argsCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgsCall" ):
                listener.enterArgsCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgsCall" ):
                listener.exitArgsCall(self)




    def argsCall(self):

        localctx = vbaParser.ArgsCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_argsCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2303
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,372,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2292
                    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 = 2291
                        self.argCall()


                    self.state = 2295
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2294
                        self.match(vbaParser.WS)


                    self.state = 2297
                    _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 = 2299
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,371,self._ctx)
                    if la_ == 1:
                        self.state = 2298
                        self.match(vbaParser.WS)

             
                self.state = 2305
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,372,self._ctx)

            self.state = 2306
            self.argCall()
            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==219:
                        self.state = 2307
                        self.match(vbaParser.WS)


                    self.state = 2310
                    _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 = 2312
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,374,self._ctx)
                    if la_ == 1:
                        self.state = 2311
                        self.match(vbaParser.WS)


                    self.state = 2315
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,375,self._ctx)
                    if la_ == 1:
                        self.state = 2314
                        self.argCall()

             
                self.state = 2321
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,376,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def BYVAL(self):
            return self.getToken(vbaParser.BYVAL, 0)

        def BYREF(self):
            return self.getToken(vbaParser.BYREF, 0)

        def PARAMARRAY(self):
            return self.getToken(vbaParser.PARAMARRAY, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_argCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgCall" ):
                listener.enterArgCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgCall" ):
                listener.exitArgCall(self)




    def argCall(self):

        localctx = vbaParser.ArgCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_argCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2323
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,377,self._ctx)
            if la_ == 1:
                self.state = 2322
                self.match(vbaParser.LPAREN)


            self.state = 2327
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,378,self._ctx)
            if la_ == 1:
                self.state = 2325
                _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 = 2326
                self.match(vbaParser.WS)


            self.state = 2330
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==202:
                self.state = 2329
                self.match(vbaParser.RPAREN)


            self.state = 2332
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictionaryCallStmtContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_dictionaryCallStmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDictionaryCallStmt" ):
                listener.enterDictionaryCallStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDictionaryCallStmt" ):
                listener.exitDictionaryCallStmt(self)




    def dictionaryCallStmt(self):

        localctx = vbaParser.DictionaryCallStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_dictionaryCallStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2334
            self.match(vbaParser.T__4)
            self.state = 2335
            self.ambiguousIdentifier()
            self.state = 2337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,380,self._ctx)
            if la_ == 1:
                self.state = 2336
                self.typeHint()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ArgContext)
            else:
                return self.getTypedRuleContext(vbaParser.ArgContext,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_argList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgList" ):
                listener.enterArgList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgList" ):
                listener.exitArgList(self)




    def argList(self):

        localctx = vbaParser.ArgListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_argList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2339
            self.match(vbaParser.LPAREN)
            self.state = 2357
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,385,self._ctx)
            if la_ == 1:
                self.state = 2341
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2340
                    self.match(vbaParser.WS)


                self.state = 2343
                self.arg()
                self.state = 2354
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,384,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2345
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2344
                            self.match(vbaParser.WS)


                        self.state = 2347
                        self.match(vbaParser.T__0)
                        self.state = 2349
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2348
                            self.match(vbaParser.WS)


                        self.state = 2351
                        self.arg() 
                    self.state = 2356
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,384,self._ctx)



            self.state = 2360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2359
                self.match(vbaParser.WS)


            self.state = 2362
            self.match(vbaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def OPTIONAL(self):
            return self.getToken(vbaParser.OPTIONAL, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def PARAMARRAY(self):
            return self.getToken(vbaParser.PARAMARRAY, 0)

        def typeHint(self):
            return self.getTypedRuleContext(vbaParser.TypeHintContext,0)


        def LPAREN(self):
            return self.getToken(vbaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(vbaParser.RPAREN, 0)

        def asTypeClause(self):
            return self.getTypedRuleContext(vbaParser.AsTypeClauseContext,0)


        def argDefaultValue(self):
            return self.getTypedRuleContext(vbaParser.ArgDefaultValueContext,0)


        def BYVAL(self):
            return self.getToken(vbaParser.BYVAL, 0)

        def BYREF(self):
            return self.getToken(vbaParser.BYREF, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_arg

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArg" ):
                listener.enterArg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArg" ):
                listener.exitArg(self)




    def arg(self):

        localctx = vbaParser.ArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,387,self._ctx)
            if la_ == 1:
                self.state = 2364
                self.match(vbaParser.OPTIONAL)
                self.state = 2365
                self.match(vbaParser.WS)


            self.state = 2370
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,388,self._ctx)
            if la_ == 1:
                self.state = 2368
                _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 = 2369
                self.match(vbaParser.WS)


            self.state = 2374
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,389,self._ctx)
            if la_ == 1:
                self.state = 2372
                self.match(vbaParser.PARAMARRAY)
                self.state = 2373
                self.match(vbaParser.WS)


            self.state = 2376
            self.ambiguousIdentifier()
            self.state = 2378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 488) != 0) or _la==186:
                self.state = 2377
                self.typeHint()


            self.state = 2388
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
            if la_ == 1:
                self.state = 2381
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2380
                    self.match(vbaParser.WS)


                self.state = 2383
                self.match(vbaParser.LPAREN)
                self.state = 2385
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2384
                    self.match(vbaParser.WS)


                self.state = 2387
                self.match(vbaParser.RPAREN)


            self.state = 2394
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,395,self._ctx)
            if la_ == 1:
                self.state = 2391
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2390
                    self.match(vbaParser.WS)


                self.state = 2393
                self.asTypeClause()


            self.state = 2400
            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.argDefaultValue()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgDefaultValueContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_argDefaultValue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgDefaultValue" ):
                listener.enterArgDefaultValue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgDefaultValue" ):
                listener.exitArgDefaultValue(self)




    def argDefaultValue(self):

        localctx = vbaParser.ArgDefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_argDefaultValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2402
            self.match(vbaParser.EQ)
            self.state = 2404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2403
                self.match(vbaParser.WS)


            self.state = 2406
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubscriptsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subscript_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.Subscript_Context)
            else:
                return self.getTypedRuleContext(vbaParser.Subscript_Context,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_subscripts

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubscripts" ):
                listener.enterSubscripts(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubscripts" ):
                listener.exitSubscripts(self)




    def subscripts(self):

        localctx = vbaParser.SubscriptsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_subscripts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2408
            self.subscript_()
            self.state = 2419
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,401,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2410
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2409
                        self.match(vbaParser.WS)


                    self.state = 2412
                    self.match(vbaParser.T__0)
                    self.state = 2414
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2413
                        self.match(vbaParser.WS)


                    self.state = 2416
                    self.subscript_() 
                self.state = 2421
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,401,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subscript_Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def valueStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.ValueStmtContext)
            else:
                return self.getTypedRuleContext(vbaParser.ValueStmtContext,i)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def TO(self):
            return self.getToken(vbaParser.TO, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_subscript_

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubscript_" ):
                listener.enterSubscript_(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubscript_" ):
                listener.exitSubscript_(self)




    def subscript_(self):

        localctx = vbaParser.Subscript_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_subscript_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2427
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,402,self._ctx)
            if la_ == 1:
                self.state = 2422
                self.valueStmt(0)
                self.state = 2423
                self.match(vbaParser.WS)
                self.state = 2424
                self.match(vbaParser.TO)
                self.state = 2425
                self.match(vbaParser.WS)


            self.state = 2429
            self.valueStmt(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AmbiguousIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.IDENTIFIER)
            else:
                return self.getToken(vbaParser.IDENTIFIER, i)

        def ambiguousKeyword(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousKeywordContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousKeywordContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_ambiguousIdentifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAmbiguousIdentifier" ):
                listener.enterAmbiguousIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAmbiguousIdentifier" ):
                listener.exitAmbiguousIdentifier(self)




    def ambiguousIdentifier(self):

        localctx = vbaParser.AmbiguousIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_ambiguousIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2433 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2433
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [220]:
                        self.state = 2431
                        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 = 2432
                        self.ambiguousKeyword()
                        pass
                    else:
                        raise NoViableAltException(self)


                else:
                    raise NoViableAltException(self)
                self.state = 2435 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,404,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AsTypeClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AS(self):
            return self.getToken(vbaParser.AS, 0)

        def type_(self):
            return self.getTypedRuleContext(vbaParser.Type_Context,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def NEW(self):
            return self.getToken(vbaParser.NEW, 0)

        def fieldLength(self):
            return self.getTypedRuleContext(vbaParser.FieldLengthContext,0)


        def getRuleIndex(self):
            return vbaParser.RULE_asTypeClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsTypeClause" ):
                listener.enterAsTypeClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsTypeClause" ):
                listener.exitAsTypeClause(self)




    def asTypeClause(self):

        localctx = vbaParser.AsTypeClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_asTypeClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2437
            self.match(vbaParser.AS)
            self.state = 2439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2438
                self.match(vbaParser.WS)


            self.state = 2443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,406,self._ctx)
            if la_ == 1:
                self.state = 2441
                self.match(vbaParser.NEW)
                self.state = 2442
                self.match(vbaParser.WS)


            self.state = 2445
            self.type_()
            self.state = 2450
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,408,self._ctx)
            if la_ == 1:
                self.state = 2447
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2446
                    self.match(vbaParser.WS)


                self.state = 2449
                self.fieldLength()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BOOLEAN(self):
            return self.getToken(vbaParser.BOOLEAN, 0)

        def BYTE(self):
            return self.getToken(vbaParser.BYTE, 0)

        def COLLECTION(self):
            return self.getToken(vbaParser.COLLECTION, 0)

        def DATE(self):
            return self.getToken(vbaParser.DATE, 0)

        def DOUBLE(self):
            return self.getToken(vbaParser.DOUBLE, 0)

        def INTEGER(self):
            return self.getToken(vbaParser.INTEGER, 0)

        def LONG(self):
            return self.getToken(vbaParser.LONG, 0)

        def SINGLE(self):
            return self.getToken(vbaParser.SINGLE, 0)

        def STRING(self):
            return self.getToken(vbaParser.STRING, 0)

        def MULT(self):
            return self.getToken(vbaParser.MULT, 0)

        def valueStmt(self):
            return self.getTypedRuleContext(vbaParser.ValueStmtContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def VARIANT(self):
            return self.getToken(vbaParser.VARIANT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_baseType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseType" ):
                listener.enterBaseType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseType" ):
                listener.exitBaseType(self)




    def baseType(self):

        localctx = vbaParser.BaseTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_baseType)
        self._la = 0 # Token type
        try:
            self.state = 2472
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2452
                self.match(vbaParser.BOOLEAN)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2453
                self.match(vbaParser.BYTE)
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2454
                self.match(vbaParser.COLLECTION)
                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2455
                self.match(vbaParser.DATE)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2456
                self.match(vbaParser.DOUBLE)
                pass
            elif token in [88]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2457
                self.match(vbaParser.INTEGER)
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2458
                self.match(vbaParser.LONG)
                pass
            elif token in [159]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2459
                self.match(vbaParser.SINGLE)
                pass
            elif token in [164]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2460
                self.match(vbaParser.STRING)
                self.state = 2469
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,411,self._ctx)
                if la_ == 1:
                    self.state = 2462
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2461
                        self.match(vbaParser.WS)


                    self.state = 2464
                    self.match(vbaParser.MULT)
                    self.state = 2466
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==219:
                        self.state = 2465
                        self.match(vbaParser.WS)


                    self.state = 2468
                    self.valueStmt(0)


                pass
            elif token in [177]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2471
                self.match(vbaParser.VARIANT)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CertainIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.IDENTIFIER)
            else:
                return self.getToken(vbaParser.IDENTIFIER, i)

        def ambiguousKeyword(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.AmbiguousKeywordContext)
            else:
                return self.getTypedRuleContext(vbaParser.AmbiguousKeywordContext,i)


        def getRuleIndex(self):
            return vbaParser.RULE_certainIdentifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCertainIdentifier" ):
                listener.enterCertainIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCertainIdentifier" ):
                listener.exitCertainIdentifier(self)




    def certainIdentifier(self):

        localctx = vbaParser.CertainIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_certainIdentifier)
        try:
            self.state = 2489
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [220]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2474
                self.match(vbaParser.IDENTIFIER)
                self.state = 2479
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,414,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2477
                        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 = 2475
                            self.ambiguousKeyword()
                            pass
                        elif token in [220]:
                            self.state = 2476
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 2481
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,414,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 = 2482
                self.ambiguousKeyword()
                self.state = 2485 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2485
                        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 = 2483
                            self.ambiguousKeyword()
                            pass
                        elif token in [220]:
                            self.state = 2484
                            self.match(vbaParser.IDENTIFIER)
                            pass
                        else:
                            raise NoViableAltException(self)


                    else:
                        raise NoViableAltException(self)
                    self.state = 2487 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,416,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ComparisonOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(vbaParser.LT, 0)

        def LEQ(self):
            return self.getToken(vbaParser.LEQ, 0)

        def GT(self):
            return self.getToken(vbaParser.GT, 0)

        def GEQ(self):
            return self.getToken(vbaParser.GEQ, 0)

        def EQ(self):
            return self.getToken(vbaParser.EQ, 0)

        def NEQ(self):
            return self.getToken(vbaParser.NEQ, 0)

        def IS(self):
            return self.getToken(vbaParser.IS, 0)

        def LIKE(self):
            return self.getToken(vbaParser.LIKE, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_comparisonOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparisonOperator" ):
                listener.enterComparisonOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparisonOperator" ):
                listener.exitComparisonOperator(self)




    def comparisonOperator(self):

        localctx = vbaParser.ComparisonOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_comparisonOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2491
            _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, 268, self.RULE_complexType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2493
            self.ambiguousIdentifier()
            self.state = 2498
            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 = 2494
                    _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 = 2495
                    self.ambiguousIdentifier() 
                self.state = 2500
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,418,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FieldLengthContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MULT(self):
            return self.getToken(vbaParser.MULT, 0)

        def INTEGERLITERAL(self):
            return self.getToken(vbaParser.INTEGERLITERAL, 0)

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def WS(self):
            return self.getToken(vbaParser.WS, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_fieldLength

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFieldLength" ):
                listener.enterFieldLength(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFieldLength" ):
                listener.exitFieldLength(self)




    def fieldLength(self):

        localctx = vbaParser.FieldLengthContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_fieldLength)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2501
            self.match(vbaParser.MULT)
            self.state = 2503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2502
                self.match(vbaParser.WS)


            self.state = 2507
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [209]:
                self.state = 2505
                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 = 2506
                self.ambiguousIdentifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LetterrangeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def certainIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.CertainIdentifierContext)
            else:
                return self.getTypedRuleContext(vbaParser.CertainIdentifierContext,i)


        def MINUS(self):
            return self.getToken(vbaParser.MINUS, 0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_letterrange

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLetterrange" ):
                listener.enterLetterrange(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLetterrange" ):
                listener.exitLetterrange(self)




    def letterrange(self):

        localctx = vbaParser.LetterrangeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_letterrange)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2509
            self.certainIdentifier()
            self.state = 2518
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,423,self._ctx)
            if la_ == 1:
                self.state = 2511
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2510
                    self.match(vbaParser.WS)


                self.state = 2513
                self.match(vbaParser.MINUS)
                self.state = 2515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2514
                    self.match(vbaParser.WS)


                self.state = 2517
                self.certainIdentifier()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineLabelContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ambiguousIdentifier(self):
            return self.getTypedRuleContext(vbaParser.AmbiguousIdentifierContext,0)


        def COLON(self):
            return self.getToken(vbaParser.COLON, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_lineLabel

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLineLabel" ):
                listener.enterLineLabel(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLineLabel" ):
                listener.exitLineLabel(self)




    def lineLabel(self):

        localctx = vbaParser.LineLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_lineLabel)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2520
            self.ambiguousIdentifier()
            self.state = 2521
            self.match(vbaParser.COLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def HEXLITERAL(self):
            return self.getToken(vbaParser.HEXLITERAL, 0)

        def OCTLITERAL(self):
            return self.getToken(vbaParser.OCTLITERAL, 0)

        def DATELITERAL(self):
            return self.getToken(vbaParser.DATELITERAL, 0)

        def DOUBLELITERAL(self):
            return self.getToken(vbaParser.DOUBLELITERAL, 0)

        def INTEGERLITERAL(self):
            return self.getToken(vbaParser.INTEGERLITERAL, 0)

        def SHORTLITERAL(self):
            return self.getToken(vbaParser.SHORTLITERAL, 0)

        def STRINGLITERAL(self):
            return self.getToken(vbaParser.STRINGLITERAL, 0)

        def TRUE(self):
            return self.getToken(vbaParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(vbaParser.FALSE, 0)

        def NOTHING(self):
            return self.getToken(vbaParser.NOTHING, 0)

        def NULL_(self):
            return self.getToken(vbaParser.NULL_, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral" ):
                listener.enterLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral" ):
                listener.exitLiteral(self)




    def literal(self):

        localctx = vbaParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2523
            _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, 278, self.RULE_type_)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,424,self._ctx)
            if la_ == 1:
                self.state = 2525
                self.baseType()
                pass

            elif la_ == 2:
                self.state = 2526
                self.complexType()
                pass


            self.state = 2537
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,427,self._ctx)
            if la_ == 1:
                self.state = 2530
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2529
                    self.match(vbaParser.WS)


                self.state = 2532
                self.match(vbaParser.LPAREN)
                self.state = 2534
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 2533
                    self.match(vbaParser.WS)


                self.state = 2536
                self.match(vbaParser.RPAREN)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeHintContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AMPERSAND(self):
            return self.getToken(vbaParser.AMPERSAND, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_typeHint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeHint" ):
                listener.enterTypeHint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeHint" ):
                listener.exitTypeHint(self)




    def typeHint(self):

        localctx = vbaParser.TypeHintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_typeHint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2539
            _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, 282, self.RULE_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2541
            _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, 284, self.RULE_ambiguousKeyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2543
            _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, 286, self.RULE_remComment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2545
            self.match(vbaParser.REMCOMMENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMMENT(self):
            return self.getToken(vbaParser.COMMENT, 0)

        def getRuleIndex(self):
            return vbaParser.RULE_comment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComment" ):
                listener.enterComment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComment" ):
                listener.exitComment(self)




    def comment(self):

        localctx = vbaParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_comment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2547
            self.match(vbaParser.COMMENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EndOfLineContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self):
            return self.getToken(vbaParser.NEWLINE, 0)

        def comment(self):
            return self.getTypedRuleContext(vbaParser.CommentContext,0)


        def remComment(self):
            return self.getTypedRuleContext(vbaParser.RemCommentContext,0)


        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_endOfLine

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEndOfLine" ):
                listener.enterEndOfLine(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEndOfLine" ):
                listener.exitEndOfLine(self)




    def endOfLine(self):

        localctx = vbaParser.EndOfLineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_endOfLine)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2550
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 2549
                self.match(vbaParser.WS)


            self.state = 2555
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [213]:
                self.state = 2552
                self.match(vbaParser.NEWLINE)
                pass
            elif token in [215]:
                self.state = 2553
                self.comment()
                pass
            elif token in [214]:
                self.state = 2554
                self.remComment()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 2558
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,430,self._ctx)
            if la_ == 1:
                self.state = 2557
                self.match(vbaParser.WS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EndOfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def endOfLine(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(vbaParser.EndOfLineContext)
            else:
                return self.getTypedRuleContext(vbaParser.EndOfLineContext,i)


        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.COLON)
            else:
                return self.getToken(vbaParser.COLON, i)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(vbaParser.WS)
            else:
                return self.getToken(vbaParser.WS, i)

        def getRuleIndex(self):
            return vbaParser.RULE_endOfStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEndOfStatement" ):
                listener.enterEndOfStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEndOfStatement" ):
                listener.exitEndOfStatement(self)




    def endOfStatement(self):

        localctx = vbaParser.EndOfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_endOfStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2570
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,434,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2568
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,433,self._ctx)
                    if la_ == 1:
                        self.state = 2560
                        self.endOfLine()
                        pass

                    elif la_ == 2:
                        self.state = 2562
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==219:
                            self.state = 2561
                            self.match(vbaParser.WS)


                        self.state = 2564
                        self.match(vbaParser.COLON)
                        self.state = 2566
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,432,self._ctx)
                        if la_ == 1:
                            self.state = 2565
                            self.match(vbaParser.WS)


                        pass

             
                self.state = 2572
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,434,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[100] = self.valueStmt_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def valueStmt_sempred(self, localctx:ValueStmtContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 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)
         




