// Code generated from VisualBasic6Parser.g4 by ANTLR 4.9.3. DO NOT EDIT.

package visualbasic6 // VisualBasic6Parser
import (
	"fmt"
	"reflect"
	"strconv"

	"github.com/antlr/antlr4/runtime/Go/antlr"
)

// Suppress unused import errors
var _ = fmt.Printf
var _ = reflect.Copy
var _ = strconv.Itoa

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

var ruleNames = []string{
	"startRule", "module", "moduleReferences", "moduleReference", "moduleReferenceValue",
	"moduleReferenceComponent", "moduleHeader", "moduleConfig", "moduleConfigElement",
	"moduleAttributes", "moduleOptions", "moduleOption", "moduleBody", "moduleBodyElement",
	"controlProperties", "cp_Properties", "cp_SingleProperty", "cp_PropertyName",
	"cp_PropertyValue", "cp_NestedProperty", "cp_ControlType", "cp_ControlIdentifier",
	"moduleBlock", "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", "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_Case", "sC_Cond",
	"sC_CondExpr", "sendkeysStmt", "setattrStmt", "setStmt", "stopStmt", "subStmt",
	"timeStmt", "typeStmt", "typeStmt_Element", "typeOfStmt", "unloadStmt",
	"unlockStmt", "valueStmt", "variableStmt", "variableListStmt", "variableSubStmt",
	"whileWendStmt", "widthStmt", "withStmt", "writeStmt", "explicitCallStmt",
	"eCS_ProcedureCall", "eCS_MemberProcedureCall", "implicitCallStmt_InBlock",
	"iCS_B_ProcedureCall", "iCS_B_MemberProcedureCall", "implicitCallStmt_InStmt",
	"iCS_S_VariableOrProcedureCall", "iCS_S_ProcedureOrArrayCall", "iCS_S_NestedProcedureCall",
	"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", "publicPrivateVisibility", "publicPrivateGlobalVisibility",
	"type_", "typeHint", "visibility", "ambiguousKeyword",
}

type VisualBasic6Parser struct {
	*antlr.BaseParser
}

// NewVisualBasic6Parser produces a new parser instance for the optional input antlr.TokenStream.
//
// The *VisualBasic6Parser instance produced may be reused by calling the SetInputStream method.
// The initial parser configuration is expensive to construct, and the object is not thread-safe;
// however, if used within a Golang sync.Pool, the construction cost amortizes well and the
// objects can be used in a thread-safe manner.
func NewVisualBasic6Parser(input antlr.TokenStream) *VisualBasic6Parser {
	this := new(VisualBasic6Parser)
	deserializer := antlr.NewATNDeserializer(nil)
	deserializedATN := deserializer.DeserializeFromUInt16(parserATN)
	decisionToDFA := make([]*antlr.DFA, len(deserializedATN.DecisionToState))
	for index, ds := range deserializedATN.DecisionToState {
		decisionToDFA[index] = antlr.NewDFA(ds, index)
	}
	this.BaseParser = antlr.NewBaseParser(input)

	this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache())
	this.RuleNames = ruleNames
	this.LiteralNames = literalNames
	this.SymbolicNames = symbolicNames
	this.GrammarFileName = "VisualBasic6Parser.g4"

	return this
}

// VisualBasic6Parser tokens.
const (
	VisualBasic6ParserEOF                   = antlr.TokenEOF
	VisualBasic6ParserACCESS                = 1
	VisualBasic6ParserADDRESSOF             = 2
	VisualBasic6ParserALIAS                 = 3
	VisualBasic6ParserAND                   = 4
	VisualBasic6ParserATTRIBUTE             = 5
	VisualBasic6ParserAPPACTIVATE           = 6
	VisualBasic6ParserAPPEND                = 7
	VisualBasic6ParserAS                    = 8
	VisualBasic6ParserBEEP                  = 9
	VisualBasic6ParserBEGIN                 = 10
	VisualBasic6ParserBEGINPROPERTY         = 11
	VisualBasic6ParserBINARY                = 12
	VisualBasic6ParserBOOLEAN               = 13
	VisualBasic6ParserBYVAL                 = 14
	VisualBasic6ParserBYREF                 = 15
	VisualBasic6ParserBYTE                  = 16
	VisualBasic6ParserCALL                  = 17
	VisualBasic6ParserCASE                  = 18
	VisualBasic6ParserCHDIR                 = 19
	VisualBasic6ParserCHDRIVE               = 20
	VisualBasic6ParserCLASS                 = 21
	VisualBasic6ParserCLOSE                 = 22
	VisualBasic6ParserCOLLECTION            = 23
	VisualBasic6ParserCONST                 = 24
	VisualBasic6ParserDATE                  = 25
	VisualBasic6ParserDECLARE               = 26
	VisualBasic6ParserDEFBOOL               = 27
	VisualBasic6ParserDEFBYTE               = 28
	VisualBasic6ParserDEFDATE               = 29
	VisualBasic6ParserDEFDBL                = 30
	VisualBasic6ParserDEFDEC                = 31
	VisualBasic6ParserDEFCUR                = 32
	VisualBasic6ParserDEFINT                = 33
	VisualBasic6ParserDEFLNG                = 34
	VisualBasic6ParserDEFOBJ                = 35
	VisualBasic6ParserDEFSNG                = 36
	VisualBasic6ParserDEFSTR                = 37
	VisualBasic6ParserDEFVAR                = 38
	VisualBasic6ParserDELETESETTING         = 39
	VisualBasic6ParserDIM                   = 40
	VisualBasic6ParserDO                    = 41
	VisualBasic6ParserDOUBLE                = 42
	VisualBasic6ParserEACH                  = 43
	VisualBasic6ParserELSE                  = 44
	VisualBasic6ParserELSEIF                = 45
	VisualBasic6ParserEND_ENUM              = 46
	VisualBasic6ParserEND_FUNCTION          = 47
	VisualBasic6ParserEND_IF                = 48
	VisualBasic6ParserEND_PROPERTY          = 49
	VisualBasic6ParserEND_SELECT            = 50
	VisualBasic6ParserEND_SUB               = 51
	VisualBasic6ParserEND_TYPE              = 52
	VisualBasic6ParserEND_WITH              = 53
	VisualBasic6ParserEND                   = 54
	VisualBasic6ParserENDPROPERTY           = 55
	VisualBasic6ParserENUM                  = 56
	VisualBasic6ParserEQV                   = 57
	VisualBasic6ParserERASE                 = 58
	VisualBasic6ParserERROR                 = 59
	VisualBasic6ParserEVENT                 = 60
	VisualBasic6ParserEXIT_DO               = 61
	VisualBasic6ParserEXIT_FOR              = 62
	VisualBasic6ParserEXIT_FUNCTION         = 63
	VisualBasic6ParserEXIT_PROPERTY         = 64
	VisualBasic6ParserEXIT_SUB              = 65
	VisualBasic6ParserFALSE                 = 66
	VisualBasic6ParserFILECOPY              = 67
	VisualBasic6ParserFRIEND                = 68
	VisualBasic6ParserFOR                   = 69
	VisualBasic6ParserFUNCTION              = 70
	VisualBasic6ParserGET                   = 71
	VisualBasic6ParserGLOBAL                = 72
	VisualBasic6ParserGOSUB                 = 73
	VisualBasic6ParserGOTO                  = 74
	VisualBasic6ParserIF                    = 75
	VisualBasic6ParserIMP                   = 76
	VisualBasic6ParserIMPLEMENTS            = 77
	VisualBasic6ParserIN                    = 78
	VisualBasic6ParserINPUT                 = 79
	VisualBasic6ParserIS                    = 80
	VisualBasic6ParserINTEGER               = 81
	VisualBasic6ParserKILL                  = 82
	VisualBasic6ParserLOAD                  = 83
	VisualBasic6ParserLOCK                  = 84
	VisualBasic6ParserLONG                  = 85
	VisualBasic6ParserLOOP                  = 86
	VisualBasic6ParserLEN                   = 87
	VisualBasic6ParserLET                   = 88
	VisualBasic6ParserLIB                   = 89
	VisualBasic6ParserLIKE                  = 90
	VisualBasic6ParserLINE_INPUT            = 91
	VisualBasic6ParserLOCK_READ             = 92
	VisualBasic6ParserLOCK_WRITE            = 93
	VisualBasic6ParserLOCK_READ_WRITE       = 94
	VisualBasic6ParserLSET                  = 95
	VisualBasic6ParserMACRO_IF              = 96
	VisualBasic6ParserMACRO_ELSEIF          = 97
	VisualBasic6ParserMACRO_ELSE            = 98
	VisualBasic6ParserMACRO_END_IF          = 99
	VisualBasic6ParserME                    = 100
	VisualBasic6ParserMID                   = 101
	VisualBasic6ParserMKDIR                 = 102
	VisualBasic6ParserMOD                   = 103
	VisualBasic6ParserNAME                  = 104
	VisualBasic6ParserNEXT                  = 105
	VisualBasic6ParserNEW                   = 106
	VisualBasic6ParserNOT                   = 107
	VisualBasic6ParserNOTHING               = 108
	VisualBasic6ParserNULL_                 = 109
	VisualBasic6ParserOBJECT                = 110
	VisualBasic6ParserON                    = 111
	VisualBasic6ParserON_ERROR              = 112
	VisualBasic6ParserON_LOCAL_ERROR        = 113
	VisualBasic6ParserOPEN                  = 114
	VisualBasic6ParserOPTIONAL              = 115
	VisualBasic6ParserOPTION_BASE           = 116
	VisualBasic6ParserOPTION_EXPLICIT       = 117
	VisualBasic6ParserOPTION_COMPARE        = 118
	VisualBasic6ParserOPTION_PRIVATE_MODULE = 119
	VisualBasic6ParserOR                    = 120
	VisualBasic6ParserOUTPUT                = 121
	VisualBasic6ParserPARAMARRAY            = 122
	VisualBasic6ParserPRESERVE              = 123
	VisualBasic6ParserPRINT                 = 124
	VisualBasic6ParserPRIVATE               = 125
	VisualBasic6ParserPROPERTY_GET          = 126
	VisualBasic6ParserPROPERTY_LET          = 127
	VisualBasic6ParserPROPERTY_SET          = 128
	VisualBasic6ParserPUBLIC                = 129
	VisualBasic6ParserPUT                   = 130
	VisualBasic6ParserRANDOM                = 131
	VisualBasic6ParserRANDOMIZE             = 132
	VisualBasic6ParserRAISEEVENT            = 133
	VisualBasic6ParserREAD                  = 134
	VisualBasic6ParserREAD_WRITE            = 135
	VisualBasic6ParserREDIM                 = 136
	VisualBasic6ParserREM                   = 137
	VisualBasic6ParserRESET                 = 138
	VisualBasic6ParserRESUME                = 139
	VisualBasic6ParserRETURN                = 140
	VisualBasic6ParserRMDIR                 = 141
	VisualBasic6ParserRSET                  = 142
	VisualBasic6ParserSAVEPICTURE           = 143
	VisualBasic6ParserSAVESETTING           = 144
	VisualBasic6ParserSEEK                  = 145
	VisualBasic6ParserSELECT                = 146
	VisualBasic6ParserSENDKEYS              = 147
	VisualBasic6ParserSET                   = 148
	VisualBasic6ParserSETATTR               = 149
	VisualBasic6ParserSHARED                = 150
	VisualBasic6ParserSINGLE                = 151
	VisualBasic6ParserSPC                   = 152
	VisualBasic6ParserSTATIC                = 153
	VisualBasic6ParserSTEP                  = 154
	VisualBasic6ParserSTOP                  = 155
	VisualBasic6ParserSTRING                = 156
	VisualBasic6ParserSUB                   = 157
	VisualBasic6ParserTAB                   = 158
	VisualBasic6ParserTEXT                  = 159
	VisualBasic6ParserTHEN                  = 160
	VisualBasic6ParserTIME                  = 161
	VisualBasic6ParserTO                    = 162
	VisualBasic6ParserTRUE                  = 163
	VisualBasic6ParserTYPE                  = 164
	VisualBasic6ParserTYPEOF                = 165
	VisualBasic6ParserUNLOAD                = 166
	VisualBasic6ParserUNLOCK                = 167
	VisualBasic6ParserUNTIL                 = 168
	VisualBasic6ParserVARIANT               = 169
	VisualBasic6ParserVERSION               = 170
	VisualBasic6ParserWEND                  = 171
	VisualBasic6ParserWHILE                 = 172
	VisualBasic6ParserWIDTH                 = 173
	VisualBasic6ParserWITH                  = 174
	VisualBasic6ParserWITHEVENTS            = 175
	VisualBasic6ParserWRITE                 = 176
	VisualBasic6ParserXOR                   = 177
	VisualBasic6ParserAMPERSAND             = 178
	VisualBasic6ParserASSIGN                = 179
	VisualBasic6ParserAT                    = 180
	VisualBasic6ParserCOLON                 = 181
	VisualBasic6ParserCOMMA                 = 182
	VisualBasic6ParserIDIV                  = 183
	VisualBasic6ParserDIV                   = 184
	VisualBasic6ParserDOLLAR                = 185
	VisualBasic6ParserDOT                   = 186
	VisualBasic6ParserEQ                    = 187
	VisualBasic6ParserEXCLAMATIONMARK       = 188
	VisualBasic6ParserGEQ                   = 189
	VisualBasic6ParserGT                    = 190
	VisualBasic6ParserHASH                  = 191
	VisualBasic6ParserLEQ                   = 192
	VisualBasic6ParserLBRACE                = 193
	VisualBasic6ParserLPAREN                = 194
	VisualBasic6ParserLT                    = 195
	VisualBasic6ParserMINUS                 = 196
	VisualBasic6ParserMINUS_EQ              = 197
	VisualBasic6ParserMULT                  = 198
	VisualBasic6ParserNEQ                   = 199
	VisualBasic6ParserPERCENT               = 200
	VisualBasic6ParserPLUS                  = 201
	VisualBasic6ParserPLUS_EQ               = 202
	VisualBasic6ParserPOW                   = 203
	VisualBasic6ParserRBRACE                = 204
	VisualBasic6ParserRPAREN                = 205
	VisualBasic6ParserSEMICOLON             = 206
	VisualBasic6ParserL_SQUARE_BRACKET      = 207
	VisualBasic6ParserR_SQUARE_BRACKET      = 208
	VisualBasic6ParserSTRINGLITERAL         = 209
	VisualBasic6ParserDATELITERAL           = 210
	VisualBasic6ParserCOLORLITERAL          = 211
	VisualBasic6ParserINTEGERLITERAL        = 212
	VisualBasic6ParserDOUBLELITERAL         = 213
	VisualBasic6ParserFILENUMBER            = 214
	VisualBasic6ParserOCTALLITERAL          = 215
	VisualBasic6ParserFRX_OFFSET            = 216
	VisualBasic6ParserGUID                  = 217
	VisualBasic6ParserIDENTIFIER            = 218
	VisualBasic6ParserLINE_CONTINUATION     = 219
	VisualBasic6ParserNEWLINE               = 220
	VisualBasic6ParserCOMMENT               = 221
	VisualBasic6ParserWS                    = 222
)

// VisualBasic6Parser rules.
const (
	VisualBasic6ParserRULE_startRule                     = 0
	VisualBasic6ParserRULE_module                        = 1
	VisualBasic6ParserRULE_moduleReferences              = 2
	VisualBasic6ParserRULE_moduleReference               = 3
	VisualBasic6ParserRULE_moduleReferenceValue          = 4
	VisualBasic6ParserRULE_moduleReferenceComponent      = 5
	VisualBasic6ParserRULE_moduleHeader                  = 6
	VisualBasic6ParserRULE_moduleConfig                  = 7
	VisualBasic6ParserRULE_moduleConfigElement           = 8
	VisualBasic6ParserRULE_moduleAttributes              = 9
	VisualBasic6ParserRULE_moduleOptions                 = 10
	VisualBasic6ParserRULE_moduleOption                  = 11
	VisualBasic6ParserRULE_moduleBody                    = 12
	VisualBasic6ParserRULE_moduleBodyElement             = 13
	VisualBasic6ParserRULE_controlProperties             = 14
	VisualBasic6ParserRULE_cp_Properties                 = 15
	VisualBasic6ParserRULE_cp_SingleProperty             = 16
	VisualBasic6ParserRULE_cp_PropertyName               = 17
	VisualBasic6ParserRULE_cp_PropertyValue              = 18
	VisualBasic6ParserRULE_cp_NestedProperty             = 19
	VisualBasic6ParserRULE_cp_ControlType                = 20
	VisualBasic6ParserRULE_cp_ControlIdentifier          = 21
	VisualBasic6ParserRULE_moduleBlock                   = 22
	VisualBasic6ParserRULE_attributeStmt                 = 23
	VisualBasic6ParserRULE_block                         = 24
	VisualBasic6ParserRULE_blockStmt                     = 25
	VisualBasic6ParserRULE_appActivateStmt               = 26
	VisualBasic6ParserRULE_beepStmt                      = 27
	VisualBasic6ParserRULE_chDirStmt                     = 28
	VisualBasic6ParserRULE_chDriveStmt                   = 29
	VisualBasic6ParserRULE_closeStmt                     = 30
	VisualBasic6ParserRULE_constStmt                     = 31
	VisualBasic6ParserRULE_constSubStmt                  = 32
	VisualBasic6ParserRULE_dateStmt                      = 33
	VisualBasic6ParserRULE_declareStmt                   = 34
	VisualBasic6ParserRULE_deftypeStmt                   = 35
	VisualBasic6ParserRULE_deleteSettingStmt             = 36
	VisualBasic6ParserRULE_doLoopStmt                    = 37
	VisualBasic6ParserRULE_endStmt                       = 38
	VisualBasic6ParserRULE_enumerationStmt               = 39
	VisualBasic6ParserRULE_enumerationStmt_Constant      = 40
	VisualBasic6ParserRULE_eraseStmt                     = 41
	VisualBasic6ParserRULE_errorStmt                     = 42
	VisualBasic6ParserRULE_eventStmt                     = 43
	VisualBasic6ParserRULE_exitStmt                      = 44
	VisualBasic6ParserRULE_filecopyStmt                  = 45
	VisualBasic6ParserRULE_forEachStmt                   = 46
	VisualBasic6ParserRULE_forNextStmt                   = 47
	VisualBasic6ParserRULE_functionStmt                  = 48
	VisualBasic6ParserRULE_getStmt                       = 49
	VisualBasic6ParserRULE_goSubStmt                     = 50
	VisualBasic6ParserRULE_goToStmt                      = 51
	VisualBasic6ParserRULE_ifThenElseStmt                = 52
	VisualBasic6ParserRULE_ifBlockStmt                   = 53
	VisualBasic6ParserRULE_ifConditionStmt               = 54
	VisualBasic6ParserRULE_ifElseIfBlockStmt             = 55
	VisualBasic6ParserRULE_ifElseBlockStmt               = 56
	VisualBasic6ParserRULE_implementsStmt                = 57
	VisualBasic6ParserRULE_inputStmt                     = 58
	VisualBasic6ParserRULE_killStmt                      = 59
	VisualBasic6ParserRULE_letStmt                       = 60
	VisualBasic6ParserRULE_lineInputStmt                 = 61
	VisualBasic6ParserRULE_loadStmt                      = 62
	VisualBasic6ParserRULE_lockStmt                      = 63
	VisualBasic6ParserRULE_lsetStmt                      = 64
	VisualBasic6ParserRULE_macroIfThenElseStmt           = 65
	VisualBasic6ParserRULE_macroIfBlockStmt              = 66
	VisualBasic6ParserRULE_macroElseIfBlockStmt          = 67
	VisualBasic6ParserRULE_macroElseBlockStmt            = 68
	VisualBasic6ParserRULE_midStmt                       = 69
	VisualBasic6ParserRULE_mkdirStmt                     = 70
	VisualBasic6ParserRULE_nameStmt                      = 71
	VisualBasic6ParserRULE_onErrorStmt                   = 72
	VisualBasic6ParserRULE_onGoToStmt                    = 73
	VisualBasic6ParserRULE_onGoSubStmt                   = 74
	VisualBasic6ParserRULE_openStmt                      = 75
	VisualBasic6ParserRULE_outputList                    = 76
	VisualBasic6ParserRULE_outputList_Expression         = 77
	VisualBasic6ParserRULE_printStmt                     = 78
	VisualBasic6ParserRULE_propertyGetStmt               = 79
	VisualBasic6ParserRULE_propertySetStmt               = 80
	VisualBasic6ParserRULE_propertyLetStmt               = 81
	VisualBasic6ParserRULE_putStmt                       = 82
	VisualBasic6ParserRULE_raiseEventStmt                = 83
	VisualBasic6ParserRULE_randomizeStmt                 = 84
	VisualBasic6ParserRULE_redimStmt                     = 85
	VisualBasic6ParserRULE_redimSubStmt                  = 86
	VisualBasic6ParserRULE_resetStmt                     = 87
	VisualBasic6ParserRULE_resumeStmt                    = 88
	VisualBasic6ParserRULE_returnStmt                    = 89
	VisualBasic6ParserRULE_rmdirStmt                     = 90
	VisualBasic6ParserRULE_rsetStmt                      = 91
	VisualBasic6ParserRULE_savepictureStmt               = 92
	VisualBasic6ParserRULE_saveSettingStmt               = 93
	VisualBasic6ParserRULE_seekStmt                      = 94
	VisualBasic6ParserRULE_selectCaseStmt                = 95
	VisualBasic6ParserRULE_sC_Case                       = 96
	VisualBasic6ParserRULE_sC_Cond                       = 97
	VisualBasic6ParserRULE_sC_CondExpr                   = 98
	VisualBasic6ParserRULE_sendkeysStmt                  = 99
	VisualBasic6ParserRULE_setattrStmt                   = 100
	VisualBasic6ParserRULE_setStmt                       = 101
	VisualBasic6ParserRULE_stopStmt                      = 102
	VisualBasic6ParserRULE_subStmt                       = 103
	VisualBasic6ParserRULE_timeStmt                      = 104
	VisualBasic6ParserRULE_typeStmt                      = 105
	VisualBasic6ParserRULE_typeStmt_Element              = 106
	VisualBasic6ParserRULE_typeOfStmt                    = 107
	VisualBasic6ParserRULE_unloadStmt                    = 108
	VisualBasic6ParserRULE_unlockStmt                    = 109
	VisualBasic6ParserRULE_valueStmt                     = 110
	VisualBasic6ParserRULE_variableStmt                  = 111
	VisualBasic6ParserRULE_variableListStmt              = 112
	VisualBasic6ParserRULE_variableSubStmt               = 113
	VisualBasic6ParserRULE_whileWendStmt                 = 114
	VisualBasic6ParserRULE_widthStmt                     = 115
	VisualBasic6ParserRULE_withStmt                      = 116
	VisualBasic6ParserRULE_writeStmt                     = 117
	VisualBasic6ParserRULE_explicitCallStmt              = 118
	VisualBasic6ParserRULE_eCS_ProcedureCall             = 119
	VisualBasic6ParserRULE_eCS_MemberProcedureCall       = 120
	VisualBasic6ParserRULE_implicitCallStmt_InBlock      = 121
	VisualBasic6ParserRULE_iCS_B_ProcedureCall           = 122
	VisualBasic6ParserRULE_iCS_B_MemberProcedureCall     = 123
	VisualBasic6ParserRULE_implicitCallStmt_InStmt       = 124
	VisualBasic6ParserRULE_iCS_S_VariableOrProcedureCall = 125
	VisualBasic6ParserRULE_iCS_S_ProcedureOrArrayCall    = 126
	VisualBasic6ParserRULE_iCS_S_NestedProcedureCall     = 127
	VisualBasic6ParserRULE_iCS_S_MembersCall             = 128
	VisualBasic6ParserRULE_iCS_S_MemberCall              = 129
	VisualBasic6ParserRULE_iCS_S_DictionaryCall          = 130
	VisualBasic6ParserRULE_argsCall                      = 131
	VisualBasic6ParserRULE_argCall                       = 132
	VisualBasic6ParserRULE_dictionaryCallStmt            = 133
	VisualBasic6ParserRULE_argList                       = 134
	VisualBasic6ParserRULE_arg                           = 135
	VisualBasic6ParserRULE_argDefaultValue               = 136
	VisualBasic6ParserRULE_subscripts                    = 137
	VisualBasic6ParserRULE_subscript_                    = 138
	VisualBasic6ParserRULE_ambiguousIdentifier           = 139
	VisualBasic6ParserRULE_asTypeClause                  = 140
	VisualBasic6ParserRULE_baseType                      = 141
	VisualBasic6ParserRULE_certainIdentifier             = 142
	VisualBasic6ParserRULE_comparisonOperator            = 143
	VisualBasic6ParserRULE_complexType                   = 144
	VisualBasic6ParserRULE_fieldLength                   = 145
	VisualBasic6ParserRULE_letterrange                   = 146
	VisualBasic6ParserRULE_lineLabel                     = 147
	VisualBasic6ParserRULE_literal                       = 148
	VisualBasic6ParserRULE_publicPrivateVisibility       = 149
	VisualBasic6ParserRULE_publicPrivateGlobalVisibility = 150
	VisualBasic6ParserRULE_type_                         = 151
	VisualBasic6ParserRULE_typeHint                      = 152
	VisualBasic6ParserRULE_visibility                    = 153
	VisualBasic6ParserRULE_ambiguousKeyword              = 154
)

// IStartRuleContext is an interface to support dynamic dispatch.
type IStartRuleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStartRuleContext differentiates from other interfaces.
	IsStartRuleContext()
}

type StartRuleContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStartRuleContext() *StartRuleContext {
	var p = new(StartRuleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_startRule
	return p
}

func (*StartRuleContext) IsStartRuleContext() {}

func NewStartRuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartRuleContext {
	var p = new(StartRuleContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_startRule

	return p
}

func (s *StartRuleContext) GetParser() antlr.Parser { return s.parser }

func (s *StartRuleContext) Module() IModuleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleContext)
}

func (s *StartRuleContext) EOF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEOF, 0)
}

func (s *StartRuleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StartRuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StartRuleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterStartRule(s)
	}
}

func (s *StartRuleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitStartRule(s)
	}
}

func (p *VisualBasic6Parser) StartRule() (localctx IStartRuleContext) {
	this := p
	_ = this

	localctx = NewStartRuleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, VisualBasic6ParserRULE_startRule)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(310)
		p.Module()
	}
	{
		p.SetState(311)
		p.Match(VisualBasic6ParserEOF)
	}

	return localctx
}

// IModuleContext is an interface to support dynamic dispatch.
type IModuleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleContext differentiates from other interfaces.
	IsModuleContext()
}

type ModuleContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleContext() *ModuleContext {
	var p = new(ModuleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_module
	return p
}

func (*ModuleContext) IsModuleContext() {}

func NewModuleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleContext {
	var p = new(ModuleContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_module

	return p
}

func (s *ModuleContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ModuleContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ModuleContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleContext) ModuleHeader() IModuleHeaderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleHeaderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleHeaderContext)
}

func (s *ModuleContext) ModuleReferences() IModuleReferencesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleReferencesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleReferencesContext)
}

func (s *ModuleContext) ControlProperties() IControlPropertiesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IControlPropertiesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IControlPropertiesContext)
}

func (s *ModuleContext) ModuleConfig() IModuleConfigContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleConfigContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleConfigContext)
}

func (s *ModuleContext) ModuleAttributes() IModuleAttributesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleAttributesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleAttributesContext)
}

func (s *ModuleContext) ModuleOptions() IModuleOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleOptionsContext)
}

func (s *ModuleContext) ModuleBody() IModuleBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyContext)
}

func (s *ModuleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModule(s)
	}
}

func (s *ModuleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModule(s)
	}
}

func (p *VisualBasic6Parser) Module() (localctx IModuleContext) {
	this := p
	_ = this

	localctx = NewModuleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, VisualBasic6ParserRULE_module)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(314)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(313)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(319)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(316)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(321)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext())
	}
	p.SetState(328)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(322)
			p.ModuleHeader()
		}
		p.SetState(324)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
				{
					p.SetState(323)
					p.Match(VisualBasic6ParserNEWLINE)
				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

			p.SetState(326)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext())
		}

	}
	p.SetState(331)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(330)
			p.ModuleReferences()
		}

	}
	p.SetState(336)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(333)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(338)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext())
	}
	p.SetState(340)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(339)
			p.ControlProperties()
		}

	}
	p.SetState(345)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(342)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(347)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())
	}
	p.SetState(349)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(348)
			p.ModuleConfig()
		}

	}
	p.SetState(354)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(351)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(356)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext())
	}
	p.SetState(358)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(357)
			p.ModuleAttributes()
		}

	}
	p.SetState(363)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(360)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(365)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())
	}
	p.SetState(367)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(366)
			p.ModuleOptions()
		}

	}
	p.SetState(372)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(369)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(374)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())
	}
	p.SetState(376)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(375)
			p.ModuleBody()
		}

	}
	p.SetState(381)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(378)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(383)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(385)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(384)
			p.Match(VisualBasic6ParserWS)
		}

	}

	return localctx
}

// IModuleReferencesContext is an interface to support dynamic dispatch.
type IModuleReferencesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleReferencesContext differentiates from other interfaces.
	IsModuleReferencesContext()
}

type ModuleReferencesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleReferencesContext() *ModuleReferencesContext {
	var p = new(ModuleReferencesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferences
	return p
}

func (*ModuleReferencesContext) IsModuleReferencesContext() {}

func NewModuleReferencesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleReferencesContext {
	var p = new(ModuleReferencesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferences

	return p
}

func (s *ModuleReferencesContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleReferencesContext) AllModuleReference() []IModuleReferenceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModuleReferenceContext)(nil)).Elem())
	var tst = make([]IModuleReferenceContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IModuleReferenceContext)
		}
	}

	return tst
}

func (s *ModuleReferencesContext) ModuleReference(i int) IModuleReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleReferenceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModuleReferenceContext)
}

func (s *ModuleReferencesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleReferencesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleReferencesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleReferences(s)
	}
}

func (s *ModuleReferencesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleReferences(s)
	}
}

func (p *VisualBasic6Parser) ModuleReferences() (localctx IModuleReferencesContext) {
	this := p
	_ = this

	localctx = NewModuleReferencesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, VisualBasic6ParserRULE_moduleReferences)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(388)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(387)
				p.ModuleReference()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(390)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleReferenceContext is an interface to support dynamic dispatch.
type IModuleReferenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleReferenceContext differentiates from other interfaces.
	IsModuleReferenceContext()
}

type ModuleReferenceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleReferenceContext() *ModuleReferenceContext {
	var p = new(ModuleReferenceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleReference
	return p
}

func (*ModuleReferenceContext) IsModuleReferenceContext() {}

func NewModuleReferenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleReferenceContext {
	var p = new(ModuleReferenceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleReference

	return p
}

func (s *ModuleReferenceContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleReferenceContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOBJECT, 0)
}

func (s *ModuleReferenceContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ModuleReferenceContext) ModuleReferenceValue() IModuleReferenceValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleReferenceValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleReferenceValueContext)
}

func (s *ModuleReferenceContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ModuleReferenceContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ModuleReferenceContext) SEMICOLON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSEMICOLON, 0)
}

func (s *ModuleReferenceContext) ModuleReferenceComponent() IModuleReferenceComponentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleReferenceComponentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleReferenceComponentContext)
}

func (s *ModuleReferenceContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleReferenceContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleReferenceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleReferenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleReferenceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleReference(s)
	}
}

func (s *ModuleReferenceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleReference(s)
	}
}

func (p *VisualBasic6Parser) ModuleReference() (localctx IModuleReferenceContext) {
	this := p
	_ = this

	localctx = NewModuleReferenceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, VisualBasic6ParserRULE_moduleReference)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(392)
		p.Match(VisualBasic6ParserOBJECT)
	}
	p.SetState(394)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(393)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(396)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(398)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(397)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(400)
		p.ModuleReferenceValue()
	}
	p.SetState(406)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSEMICOLON {
		{
			p.SetState(401)
			p.Match(VisualBasic6ParserSEMICOLON)
		}
		p.SetState(403)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(402)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(405)
			p.ModuleReferenceComponent()
		}

	}
	p.SetState(411)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(408)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(413)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleReferenceValueContext is an interface to support dynamic dispatch.
type IModuleReferenceValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleReferenceValueContext differentiates from other interfaces.
	IsModuleReferenceValueContext()
}

type ModuleReferenceValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleReferenceValueContext() *ModuleReferenceValueContext {
	var p = new(ModuleReferenceValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferenceValue
	return p
}

func (*ModuleReferenceValueContext) IsModuleReferenceValueContext() {}

func NewModuleReferenceValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleReferenceValueContext {
	var p = new(ModuleReferenceValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferenceValue

	return p
}

func (s *ModuleReferenceValueContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleReferenceValueContext) STRINGLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRINGLITERAL, 0)
}

func (s *ModuleReferenceValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleReferenceValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleReferenceValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleReferenceValue(s)
	}
}

func (s *ModuleReferenceValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleReferenceValue(s)
	}
}

func (p *VisualBasic6Parser) ModuleReferenceValue() (localctx IModuleReferenceValueContext) {
	this := p
	_ = this

	localctx = NewModuleReferenceValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, VisualBasic6ParserRULE_moduleReferenceValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(414)
		p.Match(VisualBasic6ParserSTRINGLITERAL)
	}

	return localctx
}

// IModuleReferenceComponentContext is an interface to support dynamic dispatch.
type IModuleReferenceComponentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleReferenceComponentContext differentiates from other interfaces.
	IsModuleReferenceComponentContext()
}

type ModuleReferenceComponentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleReferenceComponentContext() *ModuleReferenceComponentContext {
	var p = new(ModuleReferenceComponentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferenceComponent
	return p
}

func (*ModuleReferenceComponentContext) IsModuleReferenceComponentContext() {}

func NewModuleReferenceComponentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleReferenceComponentContext {
	var p = new(ModuleReferenceComponentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleReferenceComponent

	return p
}

func (s *ModuleReferenceComponentContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleReferenceComponentContext) STRINGLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRINGLITERAL, 0)
}

func (s *ModuleReferenceComponentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleReferenceComponentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleReferenceComponentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleReferenceComponent(s)
	}
}

func (s *ModuleReferenceComponentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleReferenceComponent(s)
	}
}

func (p *VisualBasic6Parser) ModuleReferenceComponent() (localctx IModuleReferenceComponentContext) {
	this := p
	_ = this

	localctx = NewModuleReferenceComponentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, VisualBasic6ParserRULE_moduleReferenceComponent)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(416)
		p.Match(VisualBasic6ParserSTRINGLITERAL)
	}

	return localctx
}

// IModuleHeaderContext is an interface to support dynamic dispatch.
type IModuleHeaderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleHeaderContext differentiates from other interfaces.
	IsModuleHeaderContext()
}

type ModuleHeaderContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleHeaderContext() *ModuleHeaderContext {
	var p = new(ModuleHeaderContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleHeader
	return p
}

func (*ModuleHeaderContext) IsModuleHeaderContext() {}

func NewModuleHeaderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleHeaderContext {
	var p = new(ModuleHeaderContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleHeader

	return p
}

func (s *ModuleHeaderContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleHeaderContext) VERSION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserVERSION, 0)
}

func (s *ModuleHeaderContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ModuleHeaderContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ModuleHeaderContext) DOUBLELITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOUBLELITERAL, 0)
}

func (s *ModuleHeaderContext) CLASS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCLASS, 0)
}

func (s *ModuleHeaderContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleHeaderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleHeaderContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleHeader(s)
	}
}

func (s *ModuleHeaderContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleHeader(s)
	}
}

func (p *VisualBasic6Parser) ModuleHeader() (localctx IModuleHeaderContext) {
	this := p
	_ = this

	localctx = NewModuleHeaderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, VisualBasic6ParserRULE_moduleHeader)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(418)
		p.Match(VisualBasic6ParserVERSION)
	}
	{
		p.SetState(419)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(420)
		p.Match(VisualBasic6ParserDOUBLELITERAL)
	}
	p.SetState(423)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(421)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(422)
			p.Match(VisualBasic6ParserCLASS)
		}

	}

	return localctx
}

// IModuleConfigContext is an interface to support dynamic dispatch.
type IModuleConfigContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleConfigContext differentiates from other interfaces.
	IsModuleConfigContext()
}

type ModuleConfigContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleConfigContext() *ModuleConfigContext {
	var p = new(ModuleConfigContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleConfig
	return p
}

func (*ModuleConfigContext) IsModuleConfigContext() {}

func NewModuleConfigContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleConfigContext {
	var p = new(ModuleConfigContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleConfig

	return p
}

func (s *ModuleConfigContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleConfigContext) BEGIN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEGIN, 0)
}

func (s *ModuleConfigContext) END() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND, 0)
}

func (s *ModuleConfigContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleConfigContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleConfigContext) AllModuleConfigElement() []IModuleConfigElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModuleConfigElementContext)(nil)).Elem())
	var tst = make([]IModuleConfigElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IModuleConfigElementContext)
		}
	}

	return tst
}

func (s *ModuleConfigContext) ModuleConfigElement(i int) IModuleConfigElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleConfigElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModuleConfigElementContext)
}

func (s *ModuleConfigContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleConfigContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleConfigContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleConfig(s)
	}
}

func (s *ModuleConfigContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleConfig(s)
	}
}

func (p *VisualBasic6Parser) ModuleConfig() (localctx IModuleConfigContext) {
	this := p
	_ = this

	localctx = NewModuleConfigContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, VisualBasic6ParserRULE_moduleConfig)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(425)
		p.Match(VisualBasic6ParserBEGIN)
	}
	p.SetState(427)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(426)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(429)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(432)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(431)
				p.ModuleConfigElement()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(434)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext())
	}
	{
		p.SetState(436)
		p.Match(VisualBasic6ParserEND)
	}
	p.SetState(438)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(437)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(440)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleConfigElementContext is an interface to support dynamic dispatch.
type IModuleConfigElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleConfigElementContext differentiates from other interfaces.
	IsModuleConfigElementContext()
}

type ModuleConfigElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleConfigElementContext() *ModuleConfigElementContext {
	var p = new(ModuleConfigElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleConfigElement
	return p
}

func (*ModuleConfigElementContext) IsModuleConfigElementContext() {}

func NewModuleConfigElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleConfigElementContext {
	var p = new(ModuleConfigElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleConfigElement

	return p
}

func (s *ModuleConfigElementContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleConfigElementContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ModuleConfigElementContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ModuleConfigElementContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *ModuleConfigElementContext) NEWLINE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, 0)
}

func (s *ModuleConfigElementContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ModuleConfigElementContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ModuleConfigElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleConfigElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleConfigElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleConfigElement(s)
	}
}

func (s *ModuleConfigElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleConfigElement(s)
	}
}

func (p *VisualBasic6Parser) ModuleConfigElement() (localctx IModuleConfigElementContext) {
	this := p
	_ = this

	localctx = NewModuleConfigElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, VisualBasic6ParserRULE_moduleConfigElement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(442)
		p.AmbiguousIdentifier()
	}
	p.SetState(444)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(443)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(446)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(448)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(447)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(450)
		p.Literal()
	}
	{
		p.SetState(451)
		p.Match(VisualBasic6ParserNEWLINE)
	}

	return localctx
}

// IModuleAttributesContext is an interface to support dynamic dispatch.
type IModuleAttributesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleAttributesContext differentiates from other interfaces.
	IsModuleAttributesContext()
}

type ModuleAttributesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleAttributesContext() *ModuleAttributesContext {
	var p = new(ModuleAttributesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleAttributes
	return p
}

func (*ModuleAttributesContext) IsModuleAttributesContext() {}

func NewModuleAttributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleAttributesContext {
	var p = new(ModuleAttributesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleAttributes

	return p
}

func (s *ModuleAttributesContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleAttributesContext) AllAttributeStmt() []IAttributeStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAttributeStmtContext)(nil)).Elem())
	var tst = make([]IAttributeStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAttributeStmtContext)
		}
	}

	return tst
}

func (s *ModuleAttributesContext) AttributeStmt(i int) IAttributeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAttributeStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAttributeStmtContext)
}

func (s *ModuleAttributesContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleAttributesContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleAttributesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleAttributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleAttributesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleAttributes(s)
	}
}

func (s *ModuleAttributesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleAttributes(s)
	}
}

func (p *VisualBasic6Parser) ModuleAttributes() (localctx IModuleAttributesContext) {
	this := p
	_ = this

	localctx = NewModuleAttributesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, VisualBasic6ParserRULE_moduleAttributes)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(459)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(453)
				p.AttributeStmt()
			}
			p.SetState(455)
			p.GetErrorHandler().Sync(p)
			_alt = 1
			for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
				switch _alt {
				case 1:
					{
						p.SetState(454)
						p.Match(VisualBasic6ParserNEWLINE)
					}

				default:
					panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				}

				p.SetState(457)
				p.GetErrorHandler().Sync(p)
				_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext())
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(461)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleOptionsContext is an interface to support dynamic dispatch.
type IModuleOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleOptionsContext differentiates from other interfaces.
	IsModuleOptionsContext()
}

type ModuleOptionsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleOptionsContext() *ModuleOptionsContext {
	var p = new(ModuleOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleOptions
	return p
}

func (*ModuleOptionsContext) IsModuleOptionsContext() {}

func NewModuleOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleOptionsContext {
	var p = new(ModuleOptionsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleOptions

	return p
}

func (s *ModuleOptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleOptionsContext) AllModuleOption() []IModuleOptionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModuleOptionContext)(nil)).Elem())
	var tst = make([]IModuleOptionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IModuleOptionContext)
		}
	}

	return tst
}

func (s *ModuleOptionsContext) ModuleOption(i int) IModuleOptionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleOptionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModuleOptionContext)
}

func (s *ModuleOptionsContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleOptionsContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleOptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleOptions(s)
	}
}

func (s *ModuleOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleOptions(s)
	}
}

func (p *VisualBasic6Parser) ModuleOptions() (localctx IModuleOptionsContext) {
	this := p
	_ = this

	localctx = NewModuleOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, VisualBasic6ParserRULE_moduleOptions)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(469)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(463)
				p.ModuleOption()
			}
			p.SetState(465)
			p.GetErrorHandler().Sync(p)
			_alt = 1
			for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
				switch _alt {
				case 1:
					{
						p.SetState(464)
						p.Match(VisualBasic6ParserNEWLINE)
					}

				default:
					panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				}

				p.SetState(467)
				p.GetErrorHandler().Sync(p)
				_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext())
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(471)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 32, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleOptionContext is an interface to support dynamic dispatch.
type IModuleOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleOptionContext differentiates from other interfaces.
	IsModuleOptionContext()
}

type ModuleOptionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleOptionContext() *ModuleOptionContext {
	var p = new(ModuleOptionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleOption
	return p
}

func (*ModuleOptionContext) IsModuleOptionContext() {}

func NewModuleOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleOptionContext {
	var p = new(ModuleOptionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleOption

	return p
}

func (s *ModuleOptionContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleOptionContext) CopyFrom(ctx *ModuleOptionContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *ModuleOptionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type OptionExplicitStmtContext struct {
	*ModuleOptionContext
}

func NewOptionExplicitStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionExplicitStmtContext {
	var p = new(OptionExplicitStmtContext)

	p.ModuleOptionContext = NewEmptyModuleOptionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ModuleOptionContext))

	return p
}

func (s *OptionExplicitStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionExplicitStmtContext) OPTION_EXPLICIT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTION_EXPLICIT, 0)
}

func (s *OptionExplicitStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOptionExplicitStmt(s)
	}
}

func (s *OptionExplicitStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOptionExplicitStmt(s)
	}
}

type OptionBaseStmtContext struct {
	*ModuleOptionContext
}

func NewOptionBaseStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionBaseStmtContext {
	var p = new(OptionBaseStmtContext)

	p.ModuleOptionContext = NewEmptyModuleOptionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ModuleOptionContext))

	return p
}

func (s *OptionBaseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionBaseStmtContext) OPTION_BASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTION_BASE, 0)
}

func (s *OptionBaseStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *OptionBaseStmtContext) INTEGERLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGERLITERAL, 0)
}

func (s *OptionBaseStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOptionBaseStmt(s)
	}
}

func (s *OptionBaseStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOptionBaseStmt(s)
	}
}

type OptionPrivateModuleStmtContext struct {
	*ModuleOptionContext
}

func NewOptionPrivateModuleStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionPrivateModuleStmtContext {
	var p = new(OptionPrivateModuleStmtContext)

	p.ModuleOptionContext = NewEmptyModuleOptionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ModuleOptionContext))

	return p
}

func (s *OptionPrivateModuleStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionPrivateModuleStmtContext) OPTION_PRIVATE_MODULE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTION_PRIVATE_MODULE, 0)
}

func (s *OptionPrivateModuleStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOptionPrivateModuleStmt(s)
	}
}

func (s *OptionPrivateModuleStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOptionPrivateModuleStmt(s)
	}
}

type OptionCompareStmtContext struct {
	*ModuleOptionContext
}

func NewOptionCompareStmtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OptionCompareStmtContext {
	var p = new(OptionCompareStmtContext)

	p.ModuleOptionContext = NewEmptyModuleOptionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ModuleOptionContext))

	return p
}

func (s *OptionCompareStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionCompareStmtContext) OPTION_COMPARE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTION_COMPARE, 0)
}

func (s *OptionCompareStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *OptionCompareStmtContext) BINARY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBINARY, 0)
}

func (s *OptionCompareStmtContext) TEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTEXT, 0)
}

func (s *OptionCompareStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOptionCompareStmt(s)
	}
}

func (s *OptionCompareStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOptionCompareStmt(s)
	}
}

func (p *VisualBasic6Parser) ModuleOption() (localctx IModuleOptionContext) {
	this := p
	_ = this

	localctx = NewModuleOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, VisualBasic6ParserRULE_moduleOption)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(481)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserOPTION_BASE:
		localctx = NewOptionBaseStmtContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(473)
			p.Match(VisualBasic6ParserOPTION_BASE)
		}
		{
			p.SetState(474)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(475)
			p.Match(VisualBasic6ParserINTEGERLITERAL)
		}

	case VisualBasic6ParserOPTION_COMPARE:
		localctx = NewOptionCompareStmtContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(476)
			p.Match(VisualBasic6ParserOPTION_COMPARE)
		}
		{
			p.SetState(477)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(478)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserBINARY || _la == VisualBasic6ParserTEXT) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case VisualBasic6ParserOPTION_EXPLICIT:
		localctx = NewOptionExplicitStmtContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(479)
			p.Match(VisualBasic6ParserOPTION_EXPLICIT)
		}

	case VisualBasic6ParserOPTION_PRIVATE_MODULE:
		localctx = NewOptionPrivateModuleStmtContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(480)
			p.Match(VisualBasic6ParserOPTION_PRIVATE_MODULE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IModuleBodyContext is an interface to support dynamic dispatch.
type IModuleBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleBodyContext differentiates from other interfaces.
	IsModuleBodyContext()
}

type ModuleBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleBodyContext() *ModuleBodyContext {
	var p = new(ModuleBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleBody
	return p
}

func (*ModuleBodyContext) IsModuleBodyContext() {}

func NewModuleBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleBodyContext {
	var p = new(ModuleBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleBody

	return p
}

func (s *ModuleBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleBodyContext) AllModuleBodyElement() []IModuleBodyElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModuleBodyElementContext)(nil)).Elem())
	var tst = make([]IModuleBodyElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IModuleBodyElementContext)
		}
	}

	return tst
}

func (s *ModuleBodyContext) ModuleBodyElement(i int) IModuleBodyElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyElementContext)
}

func (s *ModuleBodyContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ModuleBodyContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ModuleBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleBody(s)
	}
}

func (s *ModuleBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleBody(s)
	}
}

func (p *VisualBasic6Parser) ModuleBody() (localctx IModuleBodyContext) {
	this := p
	_ = this

	localctx = NewModuleBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, VisualBasic6ParserRULE_moduleBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(483)
		p.ModuleBodyElement()
	}
	p.SetState(492)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(485)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
				{
					p.SetState(484)
					p.Match(VisualBasic6ParserNEWLINE)
				}

				p.SetState(487)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(489)
				p.ModuleBodyElement()
			}

		}
		p.SetState(494)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())
	}

	return localctx
}

// IModuleBodyElementContext is an interface to support dynamic dispatch.
type IModuleBodyElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleBodyElementContext differentiates from other interfaces.
	IsModuleBodyElementContext()
}

type ModuleBodyElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleBodyElementContext() *ModuleBodyElementContext {
	var p = new(ModuleBodyElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleBodyElement
	return p
}

func (*ModuleBodyElementContext) IsModuleBodyElementContext() {}

func NewModuleBodyElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleBodyElementContext {
	var p = new(ModuleBodyElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleBodyElement

	return p
}

func (s *ModuleBodyElementContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleBodyElementContext) ModuleBlock() IModuleBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBlockContext)
}

func (s *ModuleBodyElementContext) ModuleOption() IModuleOptionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleOptionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleOptionContext)
}

func (s *ModuleBodyElementContext) DeclareStmt() IDeclareStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclareStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclareStmtContext)
}

func (s *ModuleBodyElementContext) EnumerationStmt() IEnumerationStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumerationStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumerationStmtContext)
}

func (s *ModuleBodyElementContext) EventStmt() IEventStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEventStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEventStmtContext)
}

func (s *ModuleBodyElementContext) FunctionStmt() IFunctionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionStmtContext)
}

func (s *ModuleBodyElementContext) MacroIfThenElseStmt() IMacroIfThenElseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMacroIfThenElseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMacroIfThenElseStmtContext)
}

func (s *ModuleBodyElementContext) PropertyGetStmt() IPropertyGetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyGetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyGetStmtContext)
}

func (s *ModuleBodyElementContext) PropertySetStmt() IPropertySetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertySetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertySetStmtContext)
}

func (s *ModuleBodyElementContext) PropertyLetStmt() IPropertyLetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyLetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyLetStmtContext)
}

func (s *ModuleBodyElementContext) SubStmt() ISubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISubStmtContext)
}

func (s *ModuleBodyElementContext) TypeStmt() ITypeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeStmtContext)
}

func (s *ModuleBodyElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleBodyElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleBodyElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleBodyElement(s)
	}
}

func (s *ModuleBodyElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleBodyElement(s)
	}
}

func (p *VisualBasic6Parser) ModuleBodyElement() (localctx IModuleBodyElementContext) {
	this := p
	_ = this

	localctx = NewModuleBodyElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, VisualBasic6ParserRULE_moduleBodyElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(507)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(495)
			p.ModuleBlock()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(496)
			p.ModuleOption()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(497)
			p.DeclareStmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(498)
			p.EnumerationStmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(499)
			p.EventStmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(500)
			p.FunctionStmt()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(501)
			p.MacroIfThenElseStmt()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(502)
			p.PropertyGetStmt()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(503)
			p.PropertySetStmt()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(504)
			p.PropertyLetStmt()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(505)
			p.SubStmt()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(506)
			p.TypeStmt()
		}

	}

	return localctx
}

// IControlPropertiesContext is an interface to support dynamic dispatch.
type IControlPropertiesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsControlPropertiesContext differentiates from other interfaces.
	IsControlPropertiesContext()
}

type ControlPropertiesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyControlPropertiesContext() *ControlPropertiesContext {
	var p = new(ControlPropertiesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_controlProperties
	return p
}

func (*ControlPropertiesContext) IsControlPropertiesContext() {}

func NewControlPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ControlPropertiesContext {
	var p = new(ControlPropertiesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_controlProperties

	return p
}

func (s *ControlPropertiesContext) GetParser() antlr.Parser { return s.parser }

func (s *ControlPropertiesContext) BEGIN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEGIN, 0)
}

func (s *ControlPropertiesContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ControlPropertiesContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ControlPropertiesContext) Cp_ControlType() ICp_ControlTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_ControlTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICp_ControlTypeContext)
}

func (s *ControlPropertiesContext) Cp_ControlIdentifier() ICp_ControlIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_ControlIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICp_ControlIdentifierContext)
}

func (s *ControlPropertiesContext) END() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND, 0)
}

func (s *ControlPropertiesContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ControlPropertiesContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ControlPropertiesContext) AllCp_Properties() []ICp_PropertiesContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICp_PropertiesContext)(nil)).Elem())
	var tst = make([]ICp_PropertiesContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICp_PropertiesContext)
		}
	}

	return tst
}

func (s *ControlPropertiesContext) Cp_Properties(i int) ICp_PropertiesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_PropertiesContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICp_PropertiesContext)
}

func (s *ControlPropertiesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ControlPropertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ControlPropertiesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterControlProperties(s)
	}
}

func (s *ControlPropertiesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitControlProperties(s)
	}
}

func (p *VisualBasic6Parser) ControlProperties() (localctx IControlPropertiesContext) {
	this := p
	_ = this

	localctx = NewControlPropertiesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, VisualBasic6ParserRULE_controlProperties)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(510)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(509)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(512)
		p.Match(VisualBasic6ParserBEGIN)
	}
	{
		p.SetState(513)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(514)
		p.Cp_ControlType()
	}
	{
		p.SetState(515)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(516)
		p.Cp_ControlIdentifier()
	}
	p.SetState(518)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(517)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(521)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(520)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(523)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(526)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(525)
				p.Cp_Properties()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(528)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext())
	}
	{
		p.SetState(530)
		p.Match(VisualBasic6ParserEND)
	}
	p.SetState(534)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(531)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		}
		p.SetState(536)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext())
	}

	return localctx
}

// ICp_PropertiesContext is an interface to support dynamic dispatch.
type ICp_PropertiesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_PropertiesContext differentiates from other interfaces.
	IsCp_PropertiesContext()
}

type Cp_PropertiesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_PropertiesContext() *Cp_PropertiesContext {
	var p = new(Cp_PropertiesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_Properties
	return p
}

func (*Cp_PropertiesContext) IsCp_PropertiesContext() {}

func NewCp_PropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_PropertiesContext {
	var p = new(Cp_PropertiesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_Properties

	return p
}

func (s *Cp_PropertiesContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_PropertiesContext) Cp_SingleProperty() ICp_SinglePropertyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_SinglePropertyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICp_SinglePropertyContext)
}

func (s *Cp_PropertiesContext) Cp_NestedProperty() ICp_NestedPropertyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_NestedPropertyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICp_NestedPropertyContext)
}

func (s *Cp_PropertiesContext) ControlProperties() IControlPropertiesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IControlPropertiesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IControlPropertiesContext)
}

func (s *Cp_PropertiesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_PropertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_PropertiesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_Properties(s)
	}
}

func (s *Cp_PropertiesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_Properties(s)
	}
}

func (p *VisualBasic6Parser) Cp_Properties() (localctx ICp_PropertiesContext) {
	this := p
	_ = this

	localctx = NewCp_PropertiesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, VisualBasic6ParserRULE_cp_Properties)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(540)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(537)
			p.Cp_SingleProperty()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(538)
			p.Cp_NestedProperty()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(539)
			p.ControlProperties()
		}

	}

	return localctx
}

// ICp_SinglePropertyContext is an interface to support dynamic dispatch.
type ICp_SinglePropertyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_SinglePropertyContext differentiates from other interfaces.
	IsCp_SinglePropertyContext()
}

type Cp_SinglePropertyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_SinglePropertyContext() *Cp_SinglePropertyContext {
	var p = new(Cp_SinglePropertyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_SingleProperty
	return p
}

func (*Cp_SinglePropertyContext) IsCp_SinglePropertyContext() {}

func NewCp_SinglePropertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_SinglePropertyContext {
	var p = new(Cp_SinglePropertyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_SingleProperty

	return p
}

func (s *Cp_SinglePropertyContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_SinglePropertyContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *Cp_SinglePropertyContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *Cp_SinglePropertyContext) Cp_PropertyValue() ICp_PropertyValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_PropertyValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICp_PropertyValueContext)
}

func (s *Cp_SinglePropertyContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *Cp_SinglePropertyContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *Cp_SinglePropertyContext) DOLLAR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOLLAR, 0)
}

func (s *Cp_SinglePropertyContext) FRX_OFFSET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFRX_OFFSET, 0)
}

func (s *Cp_SinglePropertyContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *Cp_SinglePropertyContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *Cp_SinglePropertyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_SinglePropertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_SinglePropertyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_SingleProperty(s)
	}
}

func (s *Cp_SinglePropertyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_SingleProperty(s)
	}
}

func (p *VisualBasic6Parser) Cp_SingleProperty() (localctx ICp_SinglePropertyContext) {
	this := p
	_ = this

	localctx = NewCp_SinglePropertyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, VisualBasic6ParserRULE_cp_SingleProperty)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(543)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(542)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(545)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(547)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(546)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(549)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(551)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(550)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(554)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 46, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(553)
			p.Match(VisualBasic6ParserDOLLAR)
		}

	}
	{
		p.SetState(556)
		p.Cp_PropertyValue()
	}
	p.SetState(558)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRX_OFFSET {
		{
			p.SetState(557)
			p.Match(VisualBasic6ParserFRX_OFFSET)
		}

	}
	p.SetState(561)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(560)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(563)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ICp_PropertyNameContext is an interface to support dynamic dispatch.
type ICp_PropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_PropertyNameContext differentiates from other interfaces.
	IsCp_PropertyNameContext()
}

type Cp_PropertyNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_PropertyNameContext() *Cp_PropertyNameContext {
	var p = new(Cp_PropertyNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_PropertyName
	return p
}

func (*Cp_PropertyNameContext) IsCp_PropertyNameContext() {}

func NewCp_PropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_PropertyNameContext {
	var p = new(Cp_PropertyNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_PropertyName

	return p
}

func (s *Cp_PropertyNameContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_PropertyNameContext) AllAmbiguousIdentifier() []IAmbiguousIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem())
	var tst = make([]IAmbiguousIdentifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAmbiguousIdentifierContext)
		}
	}

	return tst
}

func (s *Cp_PropertyNameContext) AmbiguousIdentifier(i int) IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *Cp_PropertyNameContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOBJECT, 0)
}

func (s *Cp_PropertyNameContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserDOT)
}

func (s *Cp_PropertyNameContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOT, i)
}

func (s *Cp_PropertyNameContext) AllLPAREN() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserLPAREN)
}

func (s *Cp_PropertyNameContext) LPAREN(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, i)
}

func (s *Cp_PropertyNameContext) AllLiteral() []ILiteralContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILiteralContext)(nil)).Elem())
	var tst = make([]ILiteralContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ILiteralContext)
		}
	}

	return tst
}

func (s *Cp_PropertyNameContext) Literal(i int) ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *Cp_PropertyNameContext) AllRPAREN() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserRPAREN)
}

func (s *Cp_PropertyNameContext) RPAREN(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, i)
}

func (s *Cp_PropertyNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_PropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_PropertyNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_PropertyName(s)
	}
}

func (s *Cp_PropertyNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_PropertyName(s)
	}
}

func (p *VisualBasic6Parser) Cp_PropertyName() (localctx ICp_PropertyNameContext) {
	this := p
	_ = this

	localctx = NewCp_PropertyNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, VisualBasic6ParserRULE_cp_PropertyName)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(567)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(565)
			p.Match(VisualBasic6ParserOBJECT)
		}
		{
			p.SetState(566)
			p.Match(VisualBasic6ParserDOT)
		}

	}
	{
		p.SetState(569)
		p.AmbiguousIdentifier()
	}
	p.SetState(574)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserLPAREN {
		{
			p.SetState(570)
			p.Match(VisualBasic6ParserLPAREN)
		}
		{
			p.SetState(571)
			p.Literal()
		}
		{
			p.SetState(572)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}
	p.SetState(586)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == VisualBasic6ParserDOT {
		{
			p.SetState(576)
			p.Match(VisualBasic6ParserDOT)
		}
		{
			p.SetState(577)
			p.AmbiguousIdentifier()
		}
		p.SetState(582)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserLPAREN {
			{
				p.SetState(578)
				p.Match(VisualBasic6ParserLPAREN)
			}
			{
				p.SetState(579)
				p.Literal()
			}
			{
				p.SetState(580)
				p.Match(VisualBasic6ParserRPAREN)
			}

		}

		p.SetState(588)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ICp_PropertyValueContext is an interface to support dynamic dispatch.
type ICp_PropertyValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_PropertyValueContext differentiates from other interfaces.
	IsCp_PropertyValueContext()
}

type Cp_PropertyValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_PropertyValueContext() *Cp_PropertyValueContext {
	var p = new(Cp_PropertyValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_PropertyValue
	return p
}

func (*Cp_PropertyValueContext) IsCp_PropertyValueContext() {}

func NewCp_PropertyValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_PropertyValueContext {
	var p = new(Cp_PropertyValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_PropertyValue

	return p
}

func (s *Cp_PropertyValueContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_PropertyValueContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *Cp_PropertyValueContext) POW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPOW, 0)
}

func (s *Cp_PropertyValueContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *Cp_PropertyValueContext) DOLLAR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOLLAR, 0)
}

func (s *Cp_PropertyValueContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLBRACE, 0)
}

func (s *Cp_PropertyValueContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRBRACE, 0)
}

func (s *Cp_PropertyValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_PropertyValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_PropertyValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_PropertyValue(s)
	}
}

func (s *Cp_PropertyValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_PropertyValue(s)
	}
}

func (p *VisualBasic6Parser) Cp_PropertyValue() (localctx ICp_PropertyValueContext) {
	this := p
	_ = this

	localctx = NewCp_PropertyValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, VisualBasic6ParserRULE_cp_PropertyValue)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(590)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserDOLLAR {
		{
			p.SetState(589)
			p.Match(VisualBasic6ParserDOLLAR)
		}

	}
	p.SetState(599)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserFALSE, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserTRUE, VisualBasic6ParserSTRINGLITERAL, VisualBasic6ParserDATELITERAL, VisualBasic6ParserCOLORLITERAL, VisualBasic6ParserINTEGERLITERAL, VisualBasic6ParserDOUBLELITERAL, VisualBasic6ParserFILENUMBER, VisualBasic6ParserOCTALLITERAL:
		{
			p.SetState(592)
			p.Literal()
		}

	case VisualBasic6ParserLBRACE:
		{
			p.SetState(593)
			p.Match(VisualBasic6ParserLBRACE)
		}
		{
			p.SetState(594)
			p.AmbiguousIdentifier()
		}
		{
			p.SetState(595)
			p.Match(VisualBasic6ParserRBRACE)
		}

	case VisualBasic6ParserPOW:
		{
			p.SetState(597)
			p.Match(VisualBasic6ParserPOW)
		}
		{
			p.SetState(598)
			p.AmbiguousIdentifier()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ICp_NestedPropertyContext is an interface to support dynamic dispatch.
type ICp_NestedPropertyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_NestedPropertyContext differentiates from other interfaces.
	IsCp_NestedPropertyContext()
}

type Cp_NestedPropertyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_NestedPropertyContext() *Cp_NestedPropertyContext {
	var p = new(Cp_NestedPropertyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_NestedProperty
	return p
}

func (*Cp_NestedPropertyContext) IsCp_NestedPropertyContext() {}

func NewCp_NestedPropertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_NestedPropertyContext {
	var p = new(Cp_NestedPropertyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_NestedProperty

	return p
}

func (s *Cp_NestedPropertyContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_NestedPropertyContext) BEGINPROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEGINPROPERTY, 0)
}

func (s *Cp_NestedPropertyContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *Cp_NestedPropertyContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *Cp_NestedPropertyContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *Cp_NestedPropertyContext) ENDPROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserENDPROPERTY, 0)
}

func (s *Cp_NestedPropertyContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *Cp_NestedPropertyContext) INTEGERLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGERLITERAL, 0)
}

func (s *Cp_NestedPropertyContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *Cp_NestedPropertyContext) GUID() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGUID, 0)
}

func (s *Cp_NestedPropertyContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *Cp_NestedPropertyContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *Cp_NestedPropertyContext) AllCp_Properties() []ICp_PropertiesContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICp_PropertiesContext)(nil)).Elem())
	var tst = make([]ICp_PropertiesContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICp_PropertiesContext)
		}
	}

	return tst
}

func (s *Cp_NestedPropertyContext) Cp_Properties(i int) ICp_PropertiesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICp_PropertiesContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICp_PropertiesContext)
}

func (s *Cp_NestedPropertyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_NestedPropertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_NestedPropertyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_NestedProperty(s)
	}
}

func (s *Cp_NestedPropertyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_NestedProperty(s)
	}
}

func (p *VisualBasic6Parser) Cp_NestedProperty() (localctx ICp_NestedPropertyContext) {
	this := p
	_ = this

	localctx = NewCp_NestedPropertyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, VisualBasic6ParserRULE_cp_NestedProperty)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(602)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(601)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(604)
		p.Match(VisualBasic6ParserBEGINPROPERTY)
	}
	{
		p.SetState(605)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(606)
		p.AmbiguousIdentifier()
	}
	p.SetState(610)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserLPAREN {
		{
			p.SetState(607)
			p.Match(VisualBasic6ParserLPAREN)
		}
		{
			p.SetState(608)
			p.Match(VisualBasic6ParserINTEGERLITERAL)
		}
		{
			p.SetState(609)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}
	p.SetState(614)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(612)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(613)
			p.Match(VisualBasic6ParserGUID)
		}

	}
	p.SetState(617)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(616)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(619)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(626)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBEGINPROPERTY)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		p.SetState(622)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBEGINPROPERTY)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
			{
				p.SetState(621)
				p.Cp_Properties()
			}

			p.SetState(624)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(628)
		p.Match(VisualBasic6ParserENDPROPERTY)
	}
	p.SetState(630)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(629)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(632)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ICp_ControlTypeContext is an interface to support dynamic dispatch.
type ICp_ControlTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_ControlTypeContext differentiates from other interfaces.
	IsCp_ControlTypeContext()
}

type Cp_ControlTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_ControlTypeContext() *Cp_ControlTypeContext {
	var p = new(Cp_ControlTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_ControlType
	return p
}

func (*Cp_ControlTypeContext) IsCp_ControlTypeContext() {}

func NewCp_ControlTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_ControlTypeContext {
	var p = new(Cp_ControlTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_ControlType

	return p
}

func (s *Cp_ControlTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_ControlTypeContext) ComplexType() IComplexTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComplexTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComplexTypeContext)
}

func (s *Cp_ControlTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_ControlTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_ControlTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_ControlType(s)
	}
}

func (s *Cp_ControlTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_ControlType(s)
	}
}

func (p *VisualBasic6Parser) Cp_ControlType() (localctx ICp_ControlTypeContext) {
	this := p
	_ = this

	localctx = NewCp_ControlTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, VisualBasic6ParserRULE_cp_ControlType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(634)
		p.ComplexType()
	}

	return localctx
}

// ICp_ControlIdentifierContext is an interface to support dynamic dispatch.
type ICp_ControlIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCp_ControlIdentifierContext differentiates from other interfaces.
	IsCp_ControlIdentifierContext()
}

type Cp_ControlIdentifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCp_ControlIdentifierContext() *Cp_ControlIdentifierContext {
	var p = new(Cp_ControlIdentifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_cp_ControlIdentifier
	return p
}

func (*Cp_ControlIdentifierContext) IsCp_ControlIdentifierContext() {}

func NewCp_ControlIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cp_ControlIdentifierContext {
	var p = new(Cp_ControlIdentifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_cp_ControlIdentifier

	return p
}

func (s *Cp_ControlIdentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *Cp_ControlIdentifierContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *Cp_ControlIdentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cp_ControlIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Cp_ControlIdentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCp_ControlIdentifier(s)
	}
}

func (s *Cp_ControlIdentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCp_ControlIdentifier(s)
	}
}

func (p *VisualBasic6Parser) Cp_ControlIdentifier() (localctx ICp_ControlIdentifierContext) {
	this := p
	_ = this

	localctx = NewCp_ControlIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, VisualBasic6ParserRULE_cp_ControlIdentifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(636)
		p.AmbiguousIdentifier()
	}

	return localctx
}

// IModuleBlockContext is an interface to support dynamic dispatch.
type IModuleBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModuleBlockContext differentiates from other interfaces.
	IsModuleBlockContext()
}

type ModuleBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModuleBlockContext() *ModuleBlockContext {
	var p = new(ModuleBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_moduleBlock
	return p
}

func (*ModuleBlockContext) IsModuleBlockContext() {}

func NewModuleBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModuleBlockContext {
	var p = new(ModuleBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_moduleBlock

	return p
}

func (s *ModuleBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *ModuleBlockContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ModuleBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ModuleBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ModuleBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterModuleBlock(s)
	}
}

func (s *ModuleBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitModuleBlock(s)
	}
}

func (p *VisualBasic6Parser) ModuleBlock() (localctx IModuleBlockContext) {
	this := p
	_ = this

	localctx = NewModuleBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, VisualBasic6ParserRULE_moduleBlock)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(638)
		p.Block()
	}

	return localctx
}

// IAttributeStmtContext is an interface to support dynamic dispatch.
type IAttributeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAttributeStmtContext differentiates from other interfaces.
	IsAttributeStmtContext()
}

type AttributeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAttributeStmtContext() *AttributeStmtContext {
	var p = new(AttributeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_attributeStmt
	return p
}

func (*AttributeStmtContext) IsAttributeStmtContext() {}

func NewAttributeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttributeStmtContext {
	var p = new(AttributeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_attributeStmt

	return p
}

func (s *AttributeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AttributeStmtContext) ATTRIBUTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserATTRIBUTE, 0)
}

func (s *AttributeStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *AttributeStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *AttributeStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *AttributeStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *AttributeStmtContext) AllLiteral() []ILiteralContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILiteralContext)(nil)).Elem())
	var tst = make([]ILiteralContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ILiteralContext)
		}
	}

	return tst
}

func (s *AttributeStmtContext) Literal(i int) ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *AttributeStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *AttributeStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *AttributeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AttributeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AttributeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterAttributeStmt(s)
	}
}

func (s *AttributeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitAttributeStmt(s)
	}
}

func (p *VisualBasic6Parser) AttributeStmt() (localctx IAttributeStmtContext) {
	this := p
	_ = this

	localctx = NewAttributeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, VisualBasic6ParserRULE_attributeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(640)
		p.Match(VisualBasic6ParserATTRIBUTE)
	}
	{
		p.SetState(641)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(642)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(644)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(643)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(646)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(648)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(647)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(650)
		p.Literal()
	}
	p.SetState(661)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(652)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(651)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(654)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(656)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(655)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(658)
				p.Literal()
			}

		}
		p.SetState(663)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext())
	}

	return localctx
}

// IBlockContext is an interface to support dynamic dispatch.
type IBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockContext differentiates from other interfaces.
	IsBlockContext()
}

type BlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockContext() *BlockContext {
	var p = new(BlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_block
	return p
}

func (*BlockContext) IsBlockContext() {}

func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext {
	var p = new(BlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_block

	return p
}

func (s *BlockContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockContext) AllBlockStmt() []IBlockStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBlockStmtContext)(nil)).Elem())
	var tst = make([]IBlockStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IBlockStmtContext)
		}
	}

	return tst
}

func (s *BlockContext) BlockStmt(i int) IBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockStmtContext)
}

func (s *BlockContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *BlockContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *BlockContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *BlockContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *BlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterBlock(s)
	}
}

func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitBlock(s)
	}
}

func (p *VisualBasic6Parser) Block() (localctx IBlockContext) {
	this := p
	_ = this

	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, VisualBasic6ParserRULE_block)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(664)
		p.BlockStmt()
	}
	p.SetState(676)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(666)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
				{
					p.SetState(665)
					p.Match(VisualBasic6ParserNEWLINE)
				}

				p.SetState(668)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			p.SetState(671)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(670)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(673)
				p.BlockStmt()
			}

		}
		p.SetState(678)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())
	}

	return localctx
}

// IBlockStmtContext is an interface to support dynamic dispatch.
type IBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockStmtContext differentiates from other interfaces.
	IsBlockStmtContext()
}

type BlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockStmtContext() *BlockStmtContext {
	var p = new(BlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_blockStmt
	return p
}

func (*BlockStmtContext) IsBlockStmtContext() {}

func NewBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockStmtContext {
	var p = new(BlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_blockStmt

	return p
}

func (s *BlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockStmtContext) AppActivateStmt() IAppActivateStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAppActivateStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAppActivateStmtContext)
}

func (s *BlockStmtContext) AttributeStmt() IAttributeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAttributeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAttributeStmtContext)
}

func (s *BlockStmtContext) BeepStmt() IBeepStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBeepStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBeepStmtContext)
}

func (s *BlockStmtContext) ChDirStmt() IChDirStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IChDirStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IChDirStmtContext)
}

func (s *BlockStmtContext) ChDriveStmt() IChDriveStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IChDriveStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IChDriveStmtContext)
}

func (s *BlockStmtContext) CloseStmt() ICloseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICloseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICloseStmtContext)
}

func (s *BlockStmtContext) ConstStmt() IConstStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstStmtContext)
}

func (s *BlockStmtContext) DateStmt() IDateStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDateStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDateStmtContext)
}

func (s *BlockStmtContext) DeleteSettingStmt() IDeleteSettingStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeleteSettingStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeleteSettingStmtContext)
}

func (s *BlockStmtContext) DeftypeStmt() IDeftypeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeftypeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeftypeStmtContext)
}

func (s *BlockStmtContext) DoLoopStmt() IDoLoopStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDoLoopStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDoLoopStmtContext)
}

func (s *BlockStmtContext) EndStmt() IEndStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEndStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEndStmtContext)
}

func (s *BlockStmtContext) EraseStmt() IEraseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEraseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEraseStmtContext)
}

func (s *BlockStmtContext) ErrorStmt() IErrorStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IErrorStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IErrorStmtContext)
}

func (s *BlockStmtContext) ExitStmt() IExitStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExitStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExitStmtContext)
}

func (s *BlockStmtContext) ExplicitCallStmt() IExplicitCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExplicitCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExplicitCallStmtContext)
}

func (s *BlockStmtContext) FilecopyStmt() IFilecopyStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilecopyStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilecopyStmtContext)
}

func (s *BlockStmtContext) ForEachStmt() IForEachStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForEachStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForEachStmtContext)
}

func (s *BlockStmtContext) ForNextStmt() IForNextStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForNextStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForNextStmtContext)
}

func (s *BlockStmtContext) GetStmt() IGetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGetStmtContext)
}

func (s *BlockStmtContext) GoSubStmt() IGoSubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGoSubStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGoSubStmtContext)
}

func (s *BlockStmtContext) GoToStmt() IGoToStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGoToStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGoToStmtContext)
}

func (s *BlockStmtContext) IfThenElseStmt() IIfThenElseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfThenElseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfThenElseStmtContext)
}

func (s *BlockStmtContext) ImplementsStmt() IImplementsStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplementsStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplementsStmtContext)
}

func (s *BlockStmtContext) InputStmt() IInputStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInputStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInputStmtContext)
}

func (s *BlockStmtContext) KillStmt() IKillStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKillStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKillStmtContext)
}

func (s *BlockStmtContext) LetStmt() ILetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILetStmtContext)
}

func (s *BlockStmtContext) LineInputStmt() ILineInputStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILineInputStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILineInputStmtContext)
}

func (s *BlockStmtContext) LineLabel() ILineLabelContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILineLabelContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILineLabelContext)
}

func (s *BlockStmtContext) LoadStmt() ILoadStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILoadStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILoadStmtContext)
}

func (s *BlockStmtContext) LockStmt() ILockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILockStmtContext)
}

func (s *BlockStmtContext) LsetStmt() ILsetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILsetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILsetStmtContext)
}

func (s *BlockStmtContext) MacroIfThenElseStmt() IMacroIfThenElseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMacroIfThenElseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMacroIfThenElseStmtContext)
}

func (s *BlockStmtContext) MidStmt() IMidStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMidStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMidStmtContext)
}

func (s *BlockStmtContext) MkdirStmt() IMkdirStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMkdirStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMkdirStmtContext)
}

func (s *BlockStmtContext) NameStmt() INameStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameStmtContext)
}

func (s *BlockStmtContext) OnErrorStmt() IOnErrorStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOnErrorStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOnErrorStmtContext)
}

func (s *BlockStmtContext) OnGoToStmt() IOnGoToStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOnGoToStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOnGoToStmtContext)
}

func (s *BlockStmtContext) OnGoSubStmt() IOnGoSubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOnGoSubStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOnGoSubStmtContext)
}

func (s *BlockStmtContext) OpenStmt() IOpenStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOpenStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOpenStmtContext)
}

func (s *BlockStmtContext) PrintStmt() IPrintStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrintStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrintStmtContext)
}

func (s *BlockStmtContext) PutStmt() IPutStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPutStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPutStmtContext)
}

func (s *BlockStmtContext) RaiseEventStmt() IRaiseEventStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRaiseEventStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRaiseEventStmtContext)
}

func (s *BlockStmtContext) RandomizeStmt() IRandomizeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRandomizeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRandomizeStmtContext)
}

func (s *BlockStmtContext) RedimStmt() IRedimStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRedimStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRedimStmtContext)
}

func (s *BlockStmtContext) ResetStmt() IResetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResetStmtContext)
}

func (s *BlockStmtContext) ResumeStmt() IResumeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResumeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResumeStmtContext)
}

func (s *BlockStmtContext) ReturnStmt() IReturnStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnStmtContext)
}

func (s *BlockStmtContext) RmdirStmt() IRmdirStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRmdirStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRmdirStmtContext)
}

func (s *BlockStmtContext) RsetStmt() IRsetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRsetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRsetStmtContext)
}

func (s *BlockStmtContext) SavepictureStmt() ISavepictureStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepictureStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepictureStmtContext)
}

func (s *BlockStmtContext) SaveSettingStmt() ISaveSettingStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISaveSettingStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISaveSettingStmtContext)
}

func (s *BlockStmtContext) SeekStmt() ISeekStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISeekStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISeekStmtContext)
}

func (s *BlockStmtContext) SelectCaseStmt() ISelectCaseStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectCaseStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelectCaseStmtContext)
}

func (s *BlockStmtContext) SendkeysStmt() ISendkeysStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISendkeysStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISendkeysStmtContext)
}

func (s *BlockStmtContext) SetattrStmt() ISetattrStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetattrStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetattrStmtContext)
}

func (s *BlockStmtContext) SetStmt() ISetStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetStmtContext)
}

func (s *BlockStmtContext) StopStmt() IStopStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStopStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStopStmtContext)
}

func (s *BlockStmtContext) TimeStmt() ITimeStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITimeStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITimeStmtContext)
}

func (s *BlockStmtContext) UnloadStmt() IUnloadStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnloadStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnloadStmtContext)
}

func (s *BlockStmtContext) UnlockStmt() IUnlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnlockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnlockStmtContext)
}

func (s *BlockStmtContext) VariableStmt() IVariableStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableStmtContext)
}

func (s *BlockStmtContext) WhileWendStmt() IWhileWendStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhileWendStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhileWendStmtContext)
}

func (s *BlockStmtContext) WidthStmt() IWidthStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWidthStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWidthStmtContext)
}

func (s *BlockStmtContext) WithStmt() IWithStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWithStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWithStmtContext)
}

func (s *BlockStmtContext) WriteStmt() IWriteStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWriteStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWriteStmtContext)
}

func (s *BlockStmtContext) ImplicitCallStmt_InBlock() IImplicitCallStmt_InBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InBlockContext)
}

func (s *BlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterBlockStmt(s)
	}
}

func (s *BlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) BlockStmt() (localctx IBlockStmtContext) {
	this := p
	_ = this

	localctx = NewBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, VisualBasic6ParserRULE_blockStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(746)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(679)
			p.AppActivateStmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(680)
			p.AttributeStmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(681)
			p.BeepStmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(682)
			p.ChDirStmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(683)
			p.ChDriveStmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(684)
			p.CloseStmt()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(685)
			p.ConstStmt()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(686)
			p.DateStmt()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(687)
			p.DeleteSettingStmt()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(688)
			p.DeftypeStmt()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(689)
			p.DoLoopStmt()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(690)
			p.EndStmt()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(691)
			p.EraseStmt()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(692)
			p.ErrorStmt()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(693)
			p.ExitStmt()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(694)
			p.ExplicitCallStmt()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(695)
			p.FilecopyStmt()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(696)
			p.ForEachStmt()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(697)
			p.ForNextStmt()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(698)
			p.GetStmt()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(699)
			p.GoSubStmt()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(700)
			p.GoToStmt()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(701)
			p.IfThenElseStmt()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(702)
			p.ImplementsStmt()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(703)
			p.InputStmt()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(704)
			p.KillStmt()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(705)
			p.LetStmt()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(706)
			p.LineInputStmt()
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(707)
			p.LineLabel()
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(708)
			p.LoadStmt()
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(709)
			p.LockStmt()
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(710)
			p.LsetStmt()
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(711)
			p.MacroIfThenElseStmt()
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(712)
			p.MidStmt()
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(713)
			p.MkdirStmt()
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(714)
			p.NameStmt()
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(715)
			p.OnErrorStmt()
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(716)
			p.OnGoToStmt()
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(717)
			p.OnGoSubStmt()
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(718)
			p.OpenStmt()
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(719)
			p.PrintStmt()
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(720)
			p.PutStmt()
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(721)
			p.RaiseEventStmt()
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(722)
			p.RandomizeStmt()
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(723)
			p.RedimStmt()
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(724)
			p.ResetStmt()
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(725)
			p.ResumeStmt()
		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(726)
			p.ReturnStmt()
		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(727)
			p.RmdirStmt()
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(728)
			p.RsetStmt()
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(729)
			p.SavepictureStmt()
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(730)
			p.SaveSettingStmt()
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(731)
			p.SeekStmt()
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(732)
			p.SelectCaseStmt()
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(733)
			p.SendkeysStmt()
		}

	case 56:
		p.EnterOuterAlt(localctx, 56)
		{
			p.SetState(734)
			p.SetattrStmt()
		}

	case 57:
		p.EnterOuterAlt(localctx, 57)
		{
			p.SetState(735)
			p.SetStmt()
		}

	case 58:
		p.EnterOuterAlt(localctx, 58)
		{
			p.SetState(736)
			p.StopStmt()
		}

	case 59:
		p.EnterOuterAlt(localctx, 59)
		{
			p.SetState(737)
			p.TimeStmt()
		}

	case 60:
		p.EnterOuterAlt(localctx, 60)
		{
			p.SetState(738)
			p.UnloadStmt()
		}

	case 61:
		p.EnterOuterAlt(localctx, 61)
		{
			p.SetState(739)
			p.UnlockStmt()
		}

	case 62:
		p.EnterOuterAlt(localctx, 62)
		{
			p.SetState(740)
			p.VariableStmt()
		}

	case 63:
		p.EnterOuterAlt(localctx, 63)
		{
			p.SetState(741)
			p.WhileWendStmt()
		}

	case 64:
		p.EnterOuterAlt(localctx, 64)
		{
			p.SetState(742)
			p.WidthStmt()
		}

	case 65:
		p.EnterOuterAlt(localctx, 65)
		{
			p.SetState(743)
			p.WithStmt()
		}

	case 66:
		p.EnterOuterAlt(localctx, 66)
		{
			p.SetState(744)
			p.WriteStmt()
		}

	case 67:
		p.EnterOuterAlt(localctx, 67)
		{
			p.SetState(745)
			p.ImplicitCallStmt_InBlock()
		}

	}

	return localctx
}

// IAppActivateStmtContext is an interface to support dynamic dispatch.
type IAppActivateStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAppActivateStmtContext differentiates from other interfaces.
	IsAppActivateStmtContext()
}

type AppActivateStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAppActivateStmtContext() *AppActivateStmtContext {
	var p = new(AppActivateStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_appActivateStmt
	return p
}

func (*AppActivateStmtContext) IsAppActivateStmtContext() {}

func NewAppActivateStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AppActivateStmtContext {
	var p = new(AppActivateStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_appActivateStmt

	return p
}

func (s *AppActivateStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *AppActivateStmtContext) APPACTIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAPPACTIVATE, 0)
}

func (s *AppActivateStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *AppActivateStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *AppActivateStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *AppActivateStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *AppActivateStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *AppActivateStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AppActivateStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AppActivateStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterAppActivateStmt(s)
	}
}

func (s *AppActivateStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitAppActivateStmt(s)
	}
}

func (p *VisualBasic6Parser) AppActivateStmt() (localctx IAppActivateStmtContext) {
	this := p
	_ = this

	localctx = NewAppActivateStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, VisualBasic6ParserRULE_appActivateStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(748)
		p.Match(VisualBasic6ParserAPPACTIVATE)
	}
	{
		p.SetState(749)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(750)
		p.valueStmt(0)
	}
	p.SetState(759)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 {
		p.SetState(752)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(751)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(754)
			p.Match(VisualBasic6ParserCOMMA)
		}
		p.SetState(756)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(755)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(758)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IBeepStmtContext is an interface to support dynamic dispatch.
type IBeepStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBeepStmtContext differentiates from other interfaces.
	IsBeepStmtContext()
}

type BeepStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBeepStmtContext() *BeepStmtContext {
	var p = new(BeepStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_beepStmt
	return p
}

func (*BeepStmtContext) IsBeepStmtContext() {}

func NewBeepStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BeepStmtContext {
	var p = new(BeepStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_beepStmt

	return p
}

func (s *BeepStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *BeepStmtContext) BEEP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEEP, 0)
}

func (s *BeepStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BeepStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BeepStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterBeepStmt(s)
	}
}

func (s *BeepStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitBeepStmt(s)
	}
}

func (p *VisualBasic6Parser) BeepStmt() (localctx IBeepStmtContext) {
	this := p
	_ = this

	localctx = NewBeepStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, VisualBasic6ParserRULE_beepStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(761)
		p.Match(VisualBasic6ParserBEEP)
	}

	return localctx
}

// IChDirStmtContext is an interface to support dynamic dispatch.
type IChDirStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsChDirStmtContext differentiates from other interfaces.
	IsChDirStmtContext()
}

type ChDirStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyChDirStmtContext() *ChDirStmtContext {
	var p = new(ChDirStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_chDirStmt
	return p
}

func (*ChDirStmtContext) IsChDirStmtContext() {}

func NewChDirStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChDirStmtContext {
	var p = new(ChDirStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_chDirStmt

	return p
}

func (s *ChDirStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ChDirStmtContext) CHDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCHDIR, 0)
}

func (s *ChDirStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ChDirStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ChDirStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ChDirStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ChDirStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterChDirStmt(s)
	}
}

func (s *ChDirStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitChDirStmt(s)
	}
}

func (p *VisualBasic6Parser) ChDirStmt() (localctx IChDirStmtContext) {
	this := p
	_ = this

	localctx = NewChDirStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, VisualBasic6ParserRULE_chDirStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(763)
		p.Match(VisualBasic6ParserCHDIR)
	}
	{
		p.SetState(764)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(765)
		p.valueStmt(0)
	}

	return localctx
}

// IChDriveStmtContext is an interface to support dynamic dispatch.
type IChDriveStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsChDriveStmtContext differentiates from other interfaces.
	IsChDriveStmtContext()
}

type ChDriveStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyChDriveStmtContext() *ChDriveStmtContext {
	var p = new(ChDriveStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_chDriveStmt
	return p
}

func (*ChDriveStmtContext) IsChDriveStmtContext() {}

func NewChDriveStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChDriveStmtContext {
	var p = new(ChDriveStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_chDriveStmt

	return p
}

func (s *ChDriveStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ChDriveStmtContext) CHDRIVE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCHDRIVE, 0)
}

func (s *ChDriveStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ChDriveStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ChDriveStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ChDriveStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ChDriveStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterChDriveStmt(s)
	}
}

func (s *ChDriveStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitChDriveStmt(s)
	}
}

func (p *VisualBasic6Parser) ChDriveStmt() (localctx IChDriveStmtContext) {
	this := p
	_ = this

	localctx = NewChDriveStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, VisualBasic6ParserRULE_chDriveStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(767)
		p.Match(VisualBasic6ParserCHDRIVE)
	}
	{
		p.SetState(768)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(769)
		p.valueStmt(0)
	}

	return localctx
}

// ICloseStmtContext is an interface to support dynamic dispatch.
type ICloseStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCloseStmtContext differentiates from other interfaces.
	IsCloseStmtContext()
}

type CloseStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCloseStmtContext() *CloseStmtContext {
	var p = new(CloseStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_closeStmt
	return p
}

func (*CloseStmtContext) IsCloseStmtContext() {}

func NewCloseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CloseStmtContext {
	var p = new(CloseStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_closeStmt

	return p
}

func (s *CloseStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *CloseStmtContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCLOSE, 0)
}

func (s *CloseStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *CloseStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *CloseStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *CloseStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *CloseStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *CloseStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *CloseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CloseStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CloseStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCloseStmt(s)
	}
}

func (s *CloseStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCloseStmt(s)
	}
}

func (p *VisualBasic6Parser) CloseStmt() (localctx ICloseStmtContext) {
	this := p
	_ = this

	localctx = NewCloseStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, VisualBasic6ParserRULE_closeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(771)
		p.Match(VisualBasic6ParserCLOSE)
	}
	p.SetState(787)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(772)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(773)
			p.valueStmt(0)
		}
		p.SetState(784)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(775)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(774)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(777)
					p.Match(VisualBasic6ParserCOMMA)
				}
				p.SetState(779)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(778)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(781)
					p.valueStmt(0)
				}

			}
			p.SetState(786)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext())
		}

	}

	return localctx
}

// IConstStmtContext is an interface to support dynamic dispatch.
type IConstStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstStmtContext differentiates from other interfaces.
	IsConstStmtContext()
}

type ConstStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstStmtContext() *ConstStmtContext {
	var p = new(ConstStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_constStmt
	return p
}

func (*ConstStmtContext) IsConstStmtContext() {}

func NewConstStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstStmtContext {
	var p = new(ConstStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_constStmt

	return p
}

func (s *ConstStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstStmtContext) CONST() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCONST, 0)
}

func (s *ConstStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ConstStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ConstStmtContext) AllConstSubStmt() []IConstSubStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstSubStmtContext)(nil)).Elem())
	var tst = make([]IConstSubStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstSubStmtContext)
		}
	}

	return tst
}

func (s *ConstStmtContext) ConstSubStmt(i int) IConstSubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstSubStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstSubStmtContext)
}

func (s *ConstStmtContext) PublicPrivateGlobalVisibility() IPublicPrivateGlobalVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPublicPrivateGlobalVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPublicPrivateGlobalVisibilityContext)
}

func (s *ConstStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *ConstStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *ConstStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterConstStmt(s)
	}
}

func (s *ConstStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitConstStmt(s)
	}
}

func (p *VisualBasic6Parser) ConstStmt() (localctx IConstStmtContext) {
	this := p
	_ = this

	localctx = NewConstStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, VisualBasic6ParserRULE_constStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(792)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(789)
			p.PublicPrivateGlobalVisibility()
		}
		{
			p.SetState(790)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(794)
		p.Match(VisualBasic6ParserCONST)
	}
	{
		p.SetState(795)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(796)
		p.ConstSubStmt()
	}
	p.SetState(807)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(798)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(797)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(800)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(802)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(801)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(804)
				p.ConstSubStmt()
			}

		}
		p.SetState(809)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())
	}

	return localctx
}

// IConstSubStmtContext is an interface to support dynamic dispatch.
type IConstSubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstSubStmtContext differentiates from other interfaces.
	IsConstSubStmtContext()
}

type ConstSubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstSubStmtContext() *ConstSubStmtContext {
	var p = new(ConstSubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_constSubStmt
	return p
}

func (*ConstSubStmtContext) IsConstSubStmtContext() {}

func NewConstSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstSubStmtContext {
	var p = new(ConstSubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_constSubStmt

	return p
}

func (s *ConstSubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstSubStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ConstSubStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ConstSubStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ConstSubStmtContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ConstSubStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ConstSubStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ConstSubStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *ConstSubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstSubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstSubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterConstSubStmt(s)
	}
}

func (s *ConstSubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitConstSubStmt(s)
	}
}

func (p *VisualBasic6Parser) ConstSubStmt() (localctx IConstSubStmtContext) {
	this := p
	_ = this

	localctx = NewConstSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, VisualBasic6ParserRULE_constSubStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(810)
		p.AmbiguousIdentifier()
	}
	p.SetState(812)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(811)
			p.TypeHint()
		}

	}
	p.SetState(816)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(814)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(815)
			p.AsTypeClause()
		}

	}
	p.SetState(819)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(818)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(821)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(823)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(822)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(825)
		p.valueStmt(0)
	}

	return localctx
}

// IDateStmtContext is an interface to support dynamic dispatch.
type IDateStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDateStmtContext differentiates from other interfaces.
	IsDateStmtContext()
}

type DateStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDateStmtContext() *DateStmtContext {
	var p = new(DateStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_dateStmt
	return p
}

func (*DateStmtContext) IsDateStmtContext() {}

func NewDateStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DateStmtContext {
	var p = new(DateStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_dateStmt

	return p
}

func (s *DateStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DateStmtContext) DATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDATE, 0)
}

func (s *DateStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *DateStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *DateStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *DateStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *DateStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DateStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DateStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDateStmt(s)
	}
}

func (s *DateStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDateStmt(s)
	}
}

func (p *VisualBasic6Parser) DateStmt() (localctx IDateStmtContext) {
	this := p
	_ = this

	localctx = NewDateStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, VisualBasic6ParserRULE_dateStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(827)
		p.Match(VisualBasic6ParserDATE)
	}
	p.SetState(829)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(828)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(831)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(833)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(832)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(835)
		p.valueStmt(0)
	}

	return localctx
}

// IDeclareStmtContext is an interface to support dynamic dispatch.
type IDeclareStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclareStmtContext differentiates from other interfaces.
	IsDeclareStmtContext()
}

type DeclareStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeclareStmtContext() *DeclareStmtContext {
	var p = new(DeclareStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_declareStmt
	return p
}

func (*DeclareStmtContext) IsDeclareStmtContext() {}

func NewDeclareStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareStmtContext {
	var p = new(DeclareStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_declareStmt

	return p
}

func (s *DeclareStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeclareStmtContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDECLARE, 0)
}

func (s *DeclareStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *DeclareStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *DeclareStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *DeclareStmtContext) LIB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLIB, 0)
}

func (s *DeclareStmtContext) AllSTRINGLITERAL() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserSTRINGLITERAL)
}

func (s *DeclareStmtContext) STRINGLITERAL(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRINGLITERAL, i)
}

func (s *DeclareStmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFUNCTION, 0)
}

func (s *DeclareStmtContext) SUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSUB, 0)
}

func (s *DeclareStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *DeclareStmtContext) AllTypeHint() []ITypeHintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeHintContext)(nil)).Elem())
	var tst = make([]ITypeHintContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeHintContext)
		}
	}

	return tst
}

func (s *DeclareStmtContext) TypeHint(i int) ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *DeclareStmtContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserALIAS, 0)
}

func (s *DeclareStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *DeclareStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *DeclareStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeclareStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeclareStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDeclareStmt(s)
	}
}

func (s *DeclareStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDeclareStmt(s)
	}
}

func (p *VisualBasic6Parser) DeclareStmt() (localctx IDeclareStmtContext) {
	this := p
	_ = this

	localctx = NewDeclareStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, VisualBasic6ParserRULE_declareStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(840)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(837)
			p.Visibility()
		}
		{
			p.SetState(838)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(842)
		p.Match(VisualBasic6ParserDECLARE)
	}
	{
		p.SetState(843)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(849)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserFUNCTION:
		{
			p.SetState(844)
			p.Match(VisualBasic6ParserFUNCTION)
		}
		p.SetState(846)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
			{
				p.SetState(845)
				p.TypeHint()
			}

		}

	case VisualBasic6ParserSUB:
		{
			p.SetState(848)
			p.Match(VisualBasic6ParserSUB)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(851)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(852)
		p.AmbiguousIdentifier()
	}
	p.SetState(854)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(853)
			p.TypeHint()
		}

	}
	{
		p.SetState(856)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(857)
		p.Match(VisualBasic6ParserLIB)
	}
	{
		p.SetState(858)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(859)
		p.Match(VisualBasic6ParserSTRINGLITERAL)
	}
	p.SetState(864)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(860)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(861)
			p.Match(VisualBasic6ParserALIAS)
		}
		{
			p.SetState(862)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(863)
			p.Match(VisualBasic6ParserSTRINGLITERAL)
		}

	}
	p.SetState(870)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) == 1 {
		p.SetState(867)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(866)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(869)
			p.ArgList()
		}

	}
	p.SetState(874)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 95, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(872)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(873)
			p.AsTypeClause()
		}

	}

	return localctx
}

// IDeftypeStmtContext is an interface to support dynamic dispatch.
type IDeftypeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeftypeStmtContext differentiates from other interfaces.
	IsDeftypeStmtContext()
}

type DeftypeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeftypeStmtContext() *DeftypeStmtContext {
	var p = new(DeftypeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_deftypeStmt
	return p
}

func (*DeftypeStmtContext) IsDeftypeStmtContext() {}

func NewDeftypeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeftypeStmtContext {
	var p = new(DeftypeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_deftypeStmt

	return p
}

func (s *DeftypeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeftypeStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *DeftypeStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *DeftypeStmtContext) AllLetterrange() []ILetterrangeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILetterrangeContext)(nil)).Elem())
	var tst = make([]ILetterrangeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ILetterrangeContext)
		}
	}

	return tst
}

func (s *DeftypeStmtContext) Letterrange(i int) ILetterrangeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILetterrangeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILetterrangeContext)
}

func (s *DeftypeStmtContext) DEFBOOL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFBOOL, 0)
}

func (s *DeftypeStmtContext) DEFBYTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFBYTE, 0)
}

func (s *DeftypeStmtContext) DEFINT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFINT, 0)
}

func (s *DeftypeStmtContext) DEFLNG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFLNG, 0)
}

func (s *DeftypeStmtContext) DEFCUR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFCUR, 0)
}

func (s *DeftypeStmtContext) DEFSNG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFSNG, 0)
}

func (s *DeftypeStmtContext) DEFDBL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDBL, 0)
}

func (s *DeftypeStmtContext) DEFDEC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDEC, 0)
}

func (s *DeftypeStmtContext) DEFDATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDATE, 0)
}

func (s *DeftypeStmtContext) DEFSTR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFSTR, 0)
}

func (s *DeftypeStmtContext) DEFOBJ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFOBJ, 0)
}

func (s *DeftypeStmtContext) DEFVAR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFVAR, 0)
}

func (s *DeftypeStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *DeftypeStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *DeftypeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeftypeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeftypeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDeftypeStmt(s)
	}
}

func (s *DeftypeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDeftypeStmt(s)
	}
}

func (p *VisualBasic6Parser) DeftypeStmt() (localctx IDeftypeStmtContext) {
	this := p
	_ = this

	localctx = NewDeftypeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, VisualBasic6ParserRULE_deftypeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(876)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-27)&-(0x1f+1)) == 0 && ((1<<uint((_la-27)))&((1<<(VisualBasic6ParserDEFBOOL-27))|(1<<(VisualBasic6ParserDEFBYTE-27))|(1<<(VisualBasic6ParserDEFDATE-27))|(1<<(VisualBasic6ParserDEFDBL-27))|(1<<(VisualBasic6ParserDEFDEC-27))|(1<<(VisualBasic6ParserDEFCUR-27))|(1<<(VisualBasic6ParserDEFINT-27))|(1<<(VisualBasic6ParserDEFLNG-27))|(1<<(VisualBasic6ParserDEFOBJ-27))|(1<<(VisualBasic6ParserDEFSNG-27))|(1<<(VisualBasic6ParserDEFSTR-27))|(1<<(VisualBasic6ParserDEFVAR-27)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(877)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(878)
		p.Letterrange()
	}
	p.SetState(889)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(880)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(879)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(882)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(884)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(883)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(886)
				p.Letterrange()
			}

		}
		p.SetState(891)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())
	}

	return localctx
}

// IDeleteSettingStmtContext is an interface to support dynamic dispatch.
type IDeleteSettingStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteSettingStmtContext differentiates from other interfaces.
	IsDeleteSettingStmtContext()
}

type DeleteSettingStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeleteSettingStmtContext() *DeleteSettingStmtContext {
	var p = new(DeleteSettingStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_deleteSettingStmt
	return p
}

func (*DeleteSettingStmtContext) IsDeleteSettingStmtContext() {}

func NewDeleteSettingStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteSettingStmtContext {
	var p = new(DeleteSettingStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_deleteSettingStmt

	return p
}

func (s *DeleteSettingStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DeleteSettingStmtContext) DELETESETTING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDELETESETTING, 0)
}

func (s *DeleteSettingStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *DeleteSettingStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *DeleteSettingStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *DeleteSettingStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *DeleteSettingStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *DeleteSettingStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *DeleteSettingStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeleteSettingStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeleteSettingStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDeleteSettingStmt(s)
	}
}

func (s *DeleteSettingStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDeleteSettingStmt(s)
	}
}

func (p *VisualBasic6Parser) DeleteSettingStmt() (localctx IDeleteSettingStmtContext) {
	this := p
	_ = this

	localctx = NewDeleteSettingStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, VisualBasic6ParserRULE_deleteSettingStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(892)
		p.Match(VisualBasic6ParserDELETESETTING)
	}
	{
		p.SetState(893)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(894)
		p.valueStmt(0)
	}
	p.SetState(896)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(895)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(898)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(900)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(899)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(902)
		p.valueStmt(0)
	}
	p.SetState(911)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 {
		p.SetState(904)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(903)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(906)
			p.Match(VisualBasic6ParserCOMMA)
		}
		p.SetState(908)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(907)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(910)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IDoLoopStmtContext is an interface to support dynamic dispatch.
type IDoLoopStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDoLoopStmtContext differentiates from other interfaces.
	IsDoLoopStmtContext()
}

type DoLoopStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDoLoopStmtContext() *DoLoopStmtContext {
	var p = new(DoLoopStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_doLoopStmt
	return p
}

func (*DoLoopStmtContext) IsDoLoopStmtContext() {}

func NewDoLoopStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoLoopStmtContext {
	var p = new(DoLoopStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_doLoopStmt

	return p
}

func (s *DoLoopStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DoLoopStmtContext) DO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDO, 0)
}

func (s *DoLoopStmtContext) LOOP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOOP, 0)
}

func (s *DoLoopStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *DoLoopStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *DoLoopStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *DoLoopStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *DoLoopStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *DoLoopStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *DoLoopStmtContext) WHILE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWHILE, 0)
}

func (s *DoLoopStmtContext) UNTIL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNTIL, 0)
}

func (s *DoLoopStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DoLoopStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DoLoopStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDoLoopStmt(s)
	}
}

func (s *DoLoopStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDoLoopStmt(s)
	}
}

func (p *VisualBasic6Parser) DoLoopStmt() (localctx IDoLoopStmtContext) {
	this := p
	_ = this

	localctx = NewDoLoopStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, VisualBasic6ParserRULE_doLoopStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(966)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 112, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(913)
			p.Match(VisualBasic6ParserDO)
		}
		p.SetState(915)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(914)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(917)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(925)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(919)
				p.Block()
			}
			p.SetState(921)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
				{
					p.SetState(920)
					p.Match(VisualBasic6ParserNEWLINE)
				}

				p.SetState(923)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}

		}
		{
			p.SetState(927)
			p.Match(VisualBasic6ParserLOOP)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(928)
			p.Match(VisualBasic6ParserDO)
		}
		{
			p.SetState(929)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(930)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserUNTIL || _la == VisualBasic6ParserWHILE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(931)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(932)
			p.valueStmt(0)
		}
		p.SetState(934)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(933)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(936)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(944)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 109, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(938)
				p.Block()
			}
			p.SetState(940)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
				{
					p.SetState(939)
					p.Match(VisualBasic6ParserNEWLINE)
				}

				p.SetState(942)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}

		}
		{
			p.SetState(946)
			p.Match(VisualBasic6ParserLOOP)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(948)
			p.Match(VisualBasic6ParserDO)
		}
		p.SetState(950)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(949)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(952)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

		{
			p.SetState(954)
			p.Block()
		}
		p.SetState(956)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(955)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(958)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

		{
			p.SetState(960)
			p.Match(VisualBasic6ParserLOOP)
		}
		{
			p.SetState(961)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(962)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserUNTIL || _la == VisualBasic6ParserWHILE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(963)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(964)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IEndStmtContext is an interface to support dynamic dispatch.
type IEndStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEndStmtContext differentiates from other interfaces.
	IsEndStmtContext()
}

type EndStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEndStmtContext() *EndStmtContext {
	var p = new(EndStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_endStmt
	return p
}

func (*EndStmtContext) IsEndStmtContext() {}

func NewEndStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EndStmtContext {
	var p = new(EndStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_endStmt

	return p
}

func (s *EndStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *EndStmtContext) END() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND, 0)
}

func (s *EndStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EndStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EndStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterEndStmt(s)
	}
}

func (s *EndStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitEndStmt(s)
	}
}

func (p *VisualBasic6Parser) EndStmt() (localctx IEndStmtContext) {
	this := p
	_ = this

	localctx = NewEndStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, VisualBasic6ParserRULE_endStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(968)
		p.Match(VisualBasic6ParserEND)
	}

	return localctx
}

// IEnumerationStmtContext is an interface to support dynamic dispatch.
type IEnumerationStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumerationStmtContext differentiates from other interfaces.
	IsEnumerationStmtContext()
}

type EnumerationStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumerationStmtContext() *EnumerationStmtContext {
	var p = new(EnumerationStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_enumerationStmt
	return p
}

func (*EnumerationStmtContext) IsEnumerationStmtContext() {}

func NewEnumerationStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumerationStmtContext {
	var p = new(EnumerationStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_enumerationStmt

	return p
}

func (s *EnumerationStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumerationStmtContext) ENUM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserENUM, 0)
}

func (s *EnumerationStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *EnumerationStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *EnumerationStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *EnumerationStmtContext) END_ENUM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_ENUM, 0)
}

func (s *EnumerationStmtContext) PublicPrivateVisibility() IPublicPrivateVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPublicPrivateVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPublicPrivateVisibilityContext)
}

func (s *EnumerationStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *EnumerationStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *EnumerationStmtContext) AllEnumerationStmt_Constant() []IEnumerationStmt_ConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumerationStmt_ConstantContext)(nil)).Elem())
	var tst = make([]IEnumerationStmt_ConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IEnumerationStmt_ConstantContext)
		}
	}

	return tst
}

func (s *EnumerationStmtContext) EnumerationStmt_Constant(i int) IEnumerationStmt_ConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumerationStmt_ConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumerationStmt_ConstantContext)
}

func (s *EnumerationStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumerationStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumerationStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterEnumerationStmt(s)
	}
}

func (s *EnumerationStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitEnumerationStmt(s)
	}
}

func (p *VisualBasic6Parser) EnumerationStmt() (localctx IEnumerationStmtContext) {
	this := p
	_ = this

	localctx = NewEnumerationStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, VisualBasic6ParserRULE_enumerationStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(973)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(970)
			p.PublicPrivateVisibility()
		}
		{
			p.SetState(971)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(975)
		p.Match(VisualBasic6ParserENUM)
	}
	{
		p.SetState(976)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(977)
		p.AmbiguousIdentifier()
	}
	p.SetState(979)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(978)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(981)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(986)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164)))) != 0) || _la == VisualBasic6ParserL_SQUARE_BRACKET || _la == VisualBasic6ParserIDENTIFIER {
		{
			p.SetState(983)
			p.EnumerationStmt_Constant()
		}

		p.SetState(988)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(989)
		p.Match(VisualBasic6ParserEND_ENUM)
	}

	return localctx
}

// IEnumerationStmt_ConstantContext is an interface to support dynamic dispatch.
type IEnumerationStmt_ConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumerationStmt_ConstantContext differentiates from other interfaces.
	IsEnumerationStmt_ConstantContext()
}

type EnumerationStmt_ConstantContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumerationStmt_ConstantContext() *EnumerationStmt_ConstantContext {
	var p = new(EnumerationStmt_ConstantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_enumerationStmt_Constant
	return p
}

func (*EnumerationStmt_ConstantContext) IsEnumerationStmt_ConstantContext() {}

func NewEnumerationStmt_ConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumerationStmt_ConstantContext {
	var p = new(EnumerationStmt_ConstantContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_enumerationStmt_Constant

	return p
}

func (s *EnumerationStmt_ConstantContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumerationStmt_ConstantContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *EnumerationStmt_ConstantContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *EnumerationStmt_ConstantContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *EnumerationStmt_ConstantContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *EnumerationStmt_ConstantContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *EnumerationStmt_ConstantContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *EnumerationStmt_ConstantContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *EnumerationStmt_ConstantContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumerationStmt_ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumerationStmt_ConstantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterEnumerationStmt_Constant(s)
	}
}

func (s *EnumerationStmt_ConstantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitEnumerationStmt_Constant(s)
	}
}

func (p *VisualBasic6Parser) EnumerationStmt_Constant() (localctx IEnumerationStmt_ConstantContext) {
	this := p
	_ = this

	localctx = NewEnumerationStmt_ConstantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, VisualBasic6ParserRULE_enumerationStmt_Constant)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(991)
		p.AmbiguousIdentifier()
	}
	p.SetState(1000)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserEQ || _la == VisualBasic6ParserWS {
		p.SetState(993)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(992)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(995)
			p.Match(VisualBasic6ParserEQ)
		}
		p.SetState(997)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(996)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(999)
			p.valueStmt(0)
		}

	}
	p.SetState(1003)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1002)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1005)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IEraseStmtContext is an interface to support dynamic dispatch.
type IEraseStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEraseStmtContext differentiates from other interfaces.
	IsEraseStmtContext()
}

type EraseStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEraseStmtContext() *EraseStmtContext {
	var p = new(EraseStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_eraseStmt
	return p
}

func (*EraseStmtContext) IsEraseStmtContext() {}

func NewEraseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EraseStmtContext {
	var p = new(EraseStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_eraseStmt

	return p
}

func (s *EraseStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *EraseStmtContext) ERASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserERASE, 0)
}

func (s *EraseStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *EraseStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *EraseStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *EraseStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *EraseStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *EraseStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *EraseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EraseStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EraseStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterEraseStmt(s)
	}
}

func (s *EraseStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitEraseStmt(s)
	}
}

func (p *VisualBasic6Parser) EraseStmt() (localctx IEraseStmtContext) {
	this := p
	_ = this

	localctx = NewEraseStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, VisualBasic6ParserRULE_eraseStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1007)
		p.Match(VisualBasic6ParserERASE)
	}
	{
		p.SetState(1008)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1009)
		p.valueStmt(0)
	}
	p.SetState(1020)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 122, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(1011)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1010)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1013)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(1015)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 121, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1014)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1017)
				p.valueStmt(0)
			}

		}
		p.SetState(1022)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 122, p.GetParserRuleContext())
	}

	return localctx
}

// IErrorStmtContext is an interface to support dynamic dispatch.
type IErrorStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsErrorStmtContext differentiates from other interfaces.
	IsErrorStmtContext()
}

type ErrorStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyErrorStmtContext() *ErrorStmtContext {
	var p = new(ErrorStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_errorStmt
	return p
}

func (*ErrorStmtContext) IsErrorStmtContext() {}

func NewErrorStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ErrorStmtContext {
	var p = new(ErrorStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_errorStmt

	return p
}

func (s *ErrorStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ErrorStmtContext) ERROR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserERROR, 0)
}

func (s *ErrorStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ErrorStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ErrorStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ErrorStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ErrorStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterErrorStmt(s)
	}
}

func (s *ErrorStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitErrorStmt(s)
	}
}

func (p *VisualBasic6Parser) ErrorStmt() (localctx IErrorStmtContext) {
	this := p
	_ = this

	localctx = NewErrorStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, VisualBasic6ParserRULE_errorStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1023)
		p.Match(VisualBasic6ParserERROR)
	}
	{
		p.SetState(1024)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1025)
		p.valueStmt(0)
	}

	return localctx
}

// IEventStmtContext is an interface to support dynamic dispatch.
type IEventStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEventStmtContext differentiates from other interfaces.
	IsEventStmtContext()
}

type EventStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEventStmtContext() *EventStmtContext {
	var p = new(EventStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_eventStmt
	return p
}

func (*EventStmtContext) IsEventStmtContext() {}

func NewEventStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventStmtContext {
	var p = new(EventStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_eventStmt

	return p
}

func (s *EventStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *EventStmtContext) EVENT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEVENT, 0)
}

func (s *EventStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *EventStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *EventStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *EventStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *EventStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *EventStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EventStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EventStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterEventStmt(s)
	}
}

func (s *EventStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitEventStmt(s)
	}
}

func (p *VisualBasic6Parser) EventStmt() (localctx IEventStmtContext) {
	this := p
	_ = this

	localctx = NewEventStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, VisualBasic6ParserRULE_eventStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1030)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1027)
			p.Visibility()
		}
		{
			p.SetState(1028)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1032)
		p.Match(VisualBasic6ParserEVENT)
	}
	{
		p.SetState(1033)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1034)
		p.AmbiguousIdentifier()
	}
	p.SetState(1036)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1035)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1038)
		p.ArgList()
	}

	return localctx
}

// IExitStmtContext is an interface to support dynamic dispatch.
type IExitStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExitStmtContext differentiates from other interfaces.
	IsExitStmtContext()
}

type ExitStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExitStmtContext() *ExitStmtContext {
	var p = new(ExitStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_exitStmt
	return p
}

func (*ExitStmtContext) IsExitStmtContext() {}

func NewExitStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExitStmtContext {
	var p = new(ExitStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_exitStmt

	return p
}

func (s *ExitStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ExitStmtContext) EXIT_DO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXIT_DO, 0)
}

func (s *ExitStmtContext) EXIT_FOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXIT_FOR, 0)
}

func (s *ExitStmtContext) EXIT_FUNCTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXIT_FUNCTION, 0)
}

func (s *ExitStmtContext) EXIT_PROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXIT_PROPERTY, 0)
}

func (s *ExitStmtContext) EXIT_SUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXIT_SUB, 0)
}

func (s *ExitStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExitStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExitStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterExitStmt(s)
	}
}

func (s *ExitStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitExitStmt(s)
	}
}

func (p *VisualBasic6Parser) ExitStmt() (localctx IExitStmtContext) {
	this := p
	_ = this

	localctx = NewExitStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, VisualBasic6ParserRULE_exitStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1040)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(VisualBasic6ParserEXIT_DO-61))|(1<<(VisualBasic6ParserEXIT_FOR-61))|(1<<(VisualBasic6ParserEXIT_FUNCTION-61))|(1<<(VisualBasic6ParserEXIT_PROPERTY-61))|(1<<(VisualBasic6ParserEXIT_SUB-61)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IFilecopyStmtContext is an interface to support dynamic dispatch.
type IFilecopyStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFilecopyStmtContext differentiates from other interfaces.
	IsFilecopyStmtContext()
}

type FilecopyStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFilecopyStmtContext() *FilecopyStmtContext {
	var p = new(FilecopyStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_filecopyStmt
	return p
}

func (*FilecopyStmtContext) IsFilecopyStmtContext() {}

func NewFilecopyStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilecopyStmtContext {
	var p = new(FilecopyStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_filecopyStmt

	return p
}

func (s *FilecopyStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *FilecopyStmtContext) FILECOPY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFILECOPY, 0)
}

func (s *FilecopyStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *FilecopyStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *FilecopyStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *FilecopyStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *FilecopyStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *FilecopyStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FilecopyStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FilecopyStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterFilecopyStmt(s)
	}
}

func (s *FilecopyStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitFilecopyStmt(s)
	}
}

func (p *VisualBasic6Parser) FilecopyStmt() (localctx IFilecopyStmtContext) {
	this := p
	_ = this

	localctx = NewFilecopyStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, VisualBasic6ParserRULE_filecopyStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1042)
		p.Match(VisualBasic6ParserFILECOPY)
	}
	{
		p.SetState(1043)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1044)
		p.valueStmt(0)
	}
	p.SetState(1046)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1045)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1048)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1050)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 126, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1049)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1052)
		p.valueStmt(0)
	}

	return localctx
}

// IForEachStmtContext is an interface to support dynamic dispatch.
type IForEachStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForEachStmtContext differentiates from other interfaces.
	IsForEachStmtContext()
}

type ForEachStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForEachStmtContext() *ForEachStmtContext {
	var p = new(ForEachStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_forEachStmt
	return p
}

func (*ForEachStmtContext) IsForEachStmtContext() {}

func NewForEachStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForEachStmtContext {
	var p = new(ForEachStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_forEachStmt

	return p
}

func (s *ForEachStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ForEachStmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFOR, 0)
}

func (s *ForEachStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ForEachStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ForEachStmtContext) EACH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEACH, 0)
}

func (s *ForEachStmtContext) AllAmbiguousIdentifier() []IAmbiguousIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem())
	var tst = make([]IAmbiguousIdentifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAmbiguousIdentifierContext)
		}
	}

	return tst
}

func (s *ForEachStmtContext) AmbiguousIdentifier(i int) IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ForEachStmtContext) IN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIN, 0)
}

func (s *ForEachStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ForEachStmtContext) NEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEXT, 0)
}

func (s *ForEachStmtContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ForEachStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ForEachStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ForEachStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ForEachStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForEachStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForEachStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterForEachStmt(s)
	}
}

func (s *ForEachStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitForEachStmt(s)
	}
}

func (p *VisualBasic6Parser) ForEachStmt() (localctx IForEachStmtContext) {
	this := p
	_ = this

	localctx = NewForEachStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, VisualBasic6ParserRULE_forEachStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1054)
		p.Match(VisualBasic6ParserFOR)
	}
	{
		p.SetState(1055)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1056)
		p.Match(VisualBasic6ParserEACH)
	}
	{
		p.SetState(1057)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1058)
		p.AmbiguousIdentifier()
	}
	p.SetState(1060)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(1059)
			p.TypeHint()
		}

	}
	{
		p.SetState(1062)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1063)
		p.Match(VisualBasic6ParserIN)
	}
	{
		p.SetState(1064)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1065)
		p.valueStmt(0)
	}
	p.SetState(1067)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1066)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1069)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1077)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1071)
			p.Block()
		}
		p.SetState(1073)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1072)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1075)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1079)
		p.Match(VisualBasic6ParserNEXT)
	}
	p.SetState(1082)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 131, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1080)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1081)
			p.AmbiguousIdentifier()
		}

	}

	return localctx
}

// IForNextStmtContext is an interface to support dynamic dispatch.
type IForNextStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForNextStmtContext differentiates from other interfaces.
	IsForNextStmtContext()
}

type ForNextStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForNextStmtContext() *ForNextStmtContext {
	var p = new(ForNextStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_forNextStmt
	return p
}

func (*ForNextStmtContext) IsForNextStmtContext() {}

func NewForNextStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForNextStmtContext {
	var p = new(ForNextStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_forNextStmt

	return p
}

func (s *ForNextStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ForNextStmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFOR, 0)
}

func (s *ForNextStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ForNextStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ForNextStmtContext) ICS_S_VariableOrProcedureCall() IICS_S_VariableOrProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_VariableOrProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_VariableOrProcedureCallContext)
}

func (s *ForNextStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ForNextStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *ForNextStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ForNextStmtContext) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *ForNextStmtContext) NEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEXT, 0)
}

func (s *ForNextStmtContext) AllTypeHint() []ITypeHintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeHintContext)(nil)).Elem())
	var tst = make([]ITypeHintContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeHintContext)
		}
	}

	return tst
}

func (s *ForNextStmtContext) TypeHint(i int) ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ForNextStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *ForNextStmtContext) STEP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTEP, 0)
}

func (s *ForNextStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *ForNextStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *ForNextStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ForNextStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ForNextStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForNextStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForNextStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterForNextStmt(s)
	}
}

func (s *ForNextStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitForNextStmt(s)
	}
}

func (p *VisualBasic6Parser) ForNextStmt() (localctx IForNextStmtContext) {
	this := p
	_ = this

	localctx = NewForNextStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, VisualBasic6ParserRULE_forNextStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1084)
		p.Match(VisualBasic6ParserFOR)
	}
	{
		p.SetState(1085)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1086)
		p.ICS_S_VariableOrProcedureCall()
	}
	p.SetState(1088)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(1087)
			p.TypeHint()
		}

	}
	p.SetState(1092)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 133, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1090)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1091)
			p.AsTypeClause()
		}

	}
	p.SetState(1095)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1094)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1097)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(1099)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 135, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1098)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1101)
		p.valueStmt(0)
	}
	{
		p.SetState(1102)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1103)
		p.Match(VisualBasic6ParserTO)
	}
	{
		p.SetState(1104)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1105)
		p.valueStmt(0)
	}
	p.SetState(1110)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1106)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1107)
			p.Match(VisualBasic6ParserSTEP)
		}
		{
			p.SetState(1108)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1109)
			p.valueStmt(0)
		}

	}
	p.SetState(1113)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1112)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1115)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1123)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1117)
			p.Block()
		}
		p.SetState(1119)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1118)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1121)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1125)
		p.Match(VisualBasic6ParserNEXT)
	}
	p.SetState(1131)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 141, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1126)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1127)
			p.AmbiguousIdentifier()
		}
		p.SetState(1129)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1128)
				p.TypeHint()
			}

		}

	}

	return localctx
}

// IFunctionStmtContext is an interface to support dynamic dispatch.
type IFunctionStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionStmtContext differentiates from other interfaces.
	IsFunctionStmtContext()
}

type FunctionStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionStmtContext() *FunctionStmtContext {
	var p = new(FunctionStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_functionStmt
	return p
}

func (*FunctionStmtContext) IsFunctionStmtContext() {}

func NewFunctionStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionStmtContext {
	var p = new(FunctionStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_functionStmt

	return p
}

func (s *FunctionStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionStmtContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFUNCTION, 0)
}

func (s *FunctionStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *FunctionStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *FunctionStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *FunctionStmtContext) END_FUNCTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_FUNCTION, 0)
}

func (s *FunctionStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *FunctionStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *FunctionStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *FunctionStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *FunctionStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *FunctionStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *FunctionStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *FunctionStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterFunctionStmt(s)
	}
}

func (s *FunctionStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitFunctionStmt(s)
	}
}

func (p *VisualBasic6Parser) FunctionStmt() (localctx IFunctionStmtContext) {
	this := p
	_ = this

	localctx = NewFunctionStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, VisualBasic6ParserRULE_functionStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1136)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1133)
			p.Visibility()
		}
		{
			p.SetState(1134)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1140)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSTATIC {
		{
			p.SetState(1138)
			p.Match(VisualBasic6ParserSTATIC)
		}
		{
			p.SetState(1139)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1142)
		p.Match(VisualBasic6ParserFUNCTION)
	}
	{
		p.SetState(1143)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1144)
		p.AmbiguousIdentifier()
	}
	p.SetState(1149)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 145, p.GetParserRuleContext()) == 1 {
		p.SetState(1146)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1145)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1148)
			p.ArgList()
		}

	}
	p.SetState(1153)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1151)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1152)
			p.AsTypeClause()
		}

	}
	p.SetState(1156)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1155)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1158)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1166)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1160)
			p.Block()
		}
		p.SetState(1162)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1161)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1164)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1168)
		p.Match(VisualBasic6ParserEND_FUNCTION)
	}

	return localctx
}

// IGetStmtContext is an interface to support dynamic dispatch.
type IGetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGetStmtContext differentiates from other interfaces.
	IsGetStmtContext()
}

type GetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetStmtContext() *GetStmtContext {
	var p = new(GetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_getStmt
	return p
}

func (*GetStmtContext) IsGetStmtContext() {}

func NewGetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetStmtContext {
	var p = new(GetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_getStmt

	return p
}

func (s *GetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *GetStmtContext) GET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGET, 0)
}

func (s *GetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *GetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *GetStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *GetStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *GetStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *GetStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *GetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterGetStmt(s)
	}
}

func (s *GetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitGetStmt(s)
	}
}

func (p *VisualBasic6Parser) GetStmt() (localctx IGetStmtContext) {
	this := p
	_ = this

	localctx = NewGetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, VisualBasic6ParserRULE_getStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1170)
		p.Match(VisualBasic6ParserGET)
	}
	{
		p.SetState(1171)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1172)
		p.valueStmt(0)
	}
	p.SetState(1174)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1173)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1176)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1178)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 151, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1177)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1181)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1180)
			p.valueStmt(0)
		}

	}
	p.SetState(1184)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1183)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1186)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1188)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 154, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1187)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1190)
		p.valueStmt(0)
	}

	return localctx
}

// IGoSubStmtContext is an interface to support dynamic dispatch.
type IGoSubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGoSubStmtContext differentiates from other interfaces.
	IsGoSubStmtContext()
}

type GoSubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGoSubStmtContext() *GoSubStmtContext {
	var p = new(GoSubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_goSubStmt
	return p
}

func (*GoSubStmtContext) IsGoSubStmtContext() {}

func NewGoSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GoSubStmtContext {
	var p = new(GoSubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_goSubStmt

	return p
}

func (s *GoSubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *GoSubStmtContext) GOSUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOSUB, 0)
}

func (s *GoSubStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *GoSubStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *GoSubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GoSubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GoSubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterGoSubStmt(s)
	}
}

func (s *GoSubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitGoSubStmt(s)
	}
}

func (p *VisualBasic6Parser) GoSubStmt() (localctx IGoSubStmtContext) {
	this := p
	_ = this

	localctx = NewGoSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, VisualBasic6ParserRULE_goSubStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1192)
		p.Match(VisualBasic6ParserGOSUB)
	}
	{
		p.SetState(1193)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1194)
		p.valueStmt(0)
	}

	return localctx
}

// IGoToStmtContext is an interface to support dynamic dispatch.
type IGoToStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGoToStmtContext differentiates from other interfaces.
	IsGoToStmtContext()
}

type GoToStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGoToStmtContext() *GoToStmtContext {
	var p = new(GoToStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_goToStmt
	return p
}

func (*GoToStmtContext) IsGoToStmtContext() {}

func NewGoToStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GoToStmtContext {
	var p = new(GoToStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_goToStmt

	return p
}

func (s *GoToStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *GoToStmtContext) GOTO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOTO, 0)
}

func (s *GoToStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *GoToStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *GoToStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GoToStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GoToStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterGoToStmt(s)
	}
}

func (s *GoToStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitGoToStmt(s)
	}
}

func (p *VisualBasic6Parser) GoToStmt() (localctx IGoToStmtContext) {
	this := p
	_ = this

	localctx = NewGoToStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, VisualBasic6ParserRULE_goToStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1196)
		p.Match(VisualBasic6ParserGOTO)
	}
	{
		p.SetState(1197)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1198)
		p.valueStmt(0)
	}

	return localctx
}

// IIfThenElseStmtContext is an interface to support dynamic dispatch.
type IIfThenElseStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfThenElseStmtContext differentiates from other interfaces.
	IsIfThenElseStmtContext()
}

type IfThenElseStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfThenElseStmtContext() *IfThenElseStmtContext {
	var p = new(IfThenElseStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ifThenElseStmt
	return p
}

func (*IfThenElseStmtContext) IsIfThenElseStmtContext() {}

func NewIfThenElseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfThenElseStmtContext {
	var p = new(IfThenElseStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ifThenElseStmt

	return p
}

func (s *IfThenElseStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IfThenElseStmtContext) CopyFrom(ctx *IfThenElseStmtContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *IfThenElseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfThenElseStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type BlockIfThenElseContext struct {
	*IfThenElseStmtContext
}

func NewBlockIfThenElseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BlockIfThenElseContext {
	var p = new(BlockIfThenElseContext)

	p.IfThenElseStmtContext = NewEmptyIfThenElseStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IfThenElseStmtContext))

	return p
}

func (s *BlockIfThenElseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockIfThenElseContext) IfBlockStmt() IIfBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfBlockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfBlockStmtContext)
}

func (s *BlockIfThenElseContext) END_IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_IF, 0)
}

func (s *BlockIfThenElseContext) AllIfElseIfBlockStmt() []IIfElseIfBlockStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIfElseIfBlockStmtContext)(nil)).Elem())
	var tst = make([]IIfElseIfBlockStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IIfElseIfBlockStmtContext)
		}
	}

	return tst
}

func (s *BlockIfThenElseContext) IfElseIfBlockStmt(i int) IIfElseIfBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfElseIfBlockStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIfElseIfBlockStmtContext)
}

func (s *BlockIfThenElseContext) IfElseBlockStmt() IIfElseBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfElseBlockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfElseBlockStmtContext)
}

func (s *BlockIfThenElseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterBlockIfThenElse(s)
	}
}

func (s *BlockIfThenElseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitBlockIfThenElse(s)
	}
}

type InlineIfThenElseContext struct {
	*IfThenElseStmtContext
}

func NewInlineIfThenElseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InlineIfThenElseContext {
	var p = new(InlineIfThenElseContext)

	p.IfThenElseStmtContext = NewEmptyIfThenElseStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IfThenElseStmtContext))

	return p
}

func (s *InlineIfThenElseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InlineIfThenElseContext) IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIF, 0)
}

func (s *InlineIfThenElseContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *InlineIfThenElseContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *InlineIfThenElseContext) IfConditionStmt() IIfConditionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionStmtContext)
}

func (s *InlineIfThenElseContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *InlineIfThenElseContext) AllBlockStmt() []IBlockStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBlockStmtContext)(nil)).Elem())
	var tst = make([]IBlockStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IBlockStmtContext)
		}
	}

	return tst
}

func (s *InlineIfThenElseContext) BlockStmt(i int) IBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockStmtContext)
}

func (s *InlineIfThenElseContext) ELSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSE, 0)
}

func (s *InlineIfThenElseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterInlineIfThenElse(s)
	}
}

func (s *InlineIfThenElseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitInlineIfThenElse(s)
	}
}

func (p *VisualBasic6Parser) IfThenElseStmt() (localctx IIfThenElseStmtContext) {
	this := p
	_ = this

	localctx = NewIfThenElseStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, VisualBasic6ParserRULE_ifThenElseStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1225)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext()) {
	case 1:
		localctx = NewInlineIfThenElseContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1200)
			p.Match(VisualBasic6ParserIF)
		}
		{
			p.SetState(1201)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1202)
			p.IfConditionStmt()
		}
		{
			p.SetState(1203)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1204)
			p.Match(VisualBasic6ParserTHEN)
		}
		{
			p.SetState(1205)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1206)
			p.BlockStmt()
		}
		p.SetState(1211)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 155, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1207)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(1208)
				p.Match(VisualBasic6ParserELSE)
			}
			{
				p.SetState(1209)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(1210)
				p.BlockStmt()
			}

		}

	case 2:
		localctx = NewBlockIfThenElseContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1213)
			p.IfBlockStmt()
		}
		p.SetState(1217)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == VisualBasic6ParserELSEIF {
			{
				p.SetState(1214)
				p.IfElseIfBlockStmt()
			}

			p.SetState(1219)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(1221)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserELSE {
			{
				p.SetState(1220)
				p.IfElseBlockStmt()
			}

		}
		{
			p.SetState(1223)
			p.Match(VisualBasic6ParserEND_IF)
		}

	}

	return localctx
}

// IIfBlockStmtContext is an interface to support dynamic dispatch.
type IIfBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfBlockStmtContext differentiates from other interfaces.
	IsIfBlockStmtContext()
}

type IfBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfBlockStmtContext() *IfBlockStmtContext {
	var p = new(IfBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ifBlockStmt
	return p
}

func (*IfBlockStmtContext) IsIfBlockStmtContext() {}

func NewIfBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfBlockStmtContext {
	var p = new(IfBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ifBlockStmt

	return p
}

func (s *IfBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IfBlockStmtContext) IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIF, 0)
}

func (s *IfBlockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *IfBlockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *IfBlockStmtContext) IfConditionStmt() IIfConditionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionStmtContext)
}

func (s *IfBlockStmtContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *IfBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *IfBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *IfBlockStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *IfBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterIfBlockStmt(s)
	}
}

func (s *IfBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitIfBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) IfBlockStmt() (localctx IIfBlockStmtContext) {
	this := p
	_ = this

	localctx = NewIfBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, VisualBasic6ParserRULE_ifBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1227)
		p.Match(VisualBasic6ParserIF)
	}
	{
		p.SetState(1228)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1229)
		p.IfConditionStmt()
	}
	{
		p.SetState(1230)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1231)
		p.Match(VisualBasic6ParserTHEN)
	}
	p.SetState(1233)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1232)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1235)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1243)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 161, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1237)
			p.Block()
		}
		p.SetState(1239)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1238)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1241)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IIfConditionStmtContext is an interface to support dynamic dispatch.
type IIfConditionStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfConditionStmtContext differentiates from other interfaces.
	IsIfConditionStmtContext()
}

type IfConditionStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfConditionStmtContext() *IfConditionStmtContext {
	var p = new(IfConditionStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ifConditionStmt
	return p
}

func (*IfConditionStmtContext) IsIfConditionStmtContext() {}

func NewIfConditionStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionStmtContext {
	var p = new(IfConditionStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ifConditionStmt

	return p
}

func (s *IfConditionStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IfConditionStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *IfConditionStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfConditionStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfConditionStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterIfConditionStmt(s)
	}
}

func (s *IfConditionStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitIfConditionStmt(s)
	}
}

func (p *VisualBasic6Parser) IfConditionStmt() (localctx IIfConditionStmtContext) {
	this := p
	_ = this

	localctx = NewIfConditionStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, VisualBasic6ParserRULE_ifConditionStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1245)
		p.valueStmt(0)
	}

	return localctx
}

// IIfElseIfBlockStmtContext is an interface to support dynamic dispatch.
type IIfElseIfBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfElseIfBlockStmtContext differentiates from other interfaces.
	IsIfElseIfBlockStmtContext()
}

type IfElseIfBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfElseIfBlockStmtContext() *IfElseIfBlockStmtContext {
	var p = new(IfElseIfBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ifElseIfBlockStmt
	return p
}

func (*IfElseIfBlockStmtContext) IsIfElseIfBlockStmtContext() {}

func NewIfElseIfBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfElseIfBlockStmtContext {
	var p = new(IfElseIfBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ifElseIfBlockStmt

	return p
}

func (s *IfElseIfBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IfElseIfBlockStmtContext) ELSEIF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSEIF, 0)
}

func (s *IfElseIfBlockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *IfElseIfBlockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *IfElseIfBlockStmtContext) IfConditionStmt() IIfConditionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionStmtContext)
}

func (s *IfElseIfBlockStmtContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *IfElseIfBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *IfElseIfBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *IfElseIfBlockStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *IfElseIfBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfElseIfBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfElseIfBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterIfElseIfBlockStmt(s)
	}
}

func (s *IfElseIfBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitIfElseIfBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) IfElseIfBlockStmt() (localctx IIfElseIfBlockStmtContext) {
	this := p
	_ = this

	localctx = NewIfElseIfBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, VisualBasic6ParserRULE_ifElseIfBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1247)
		p.Match(VisualBasic6ParserELSEIF)
	}
	{
		p.SetState(1248)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1249)
		p.IfConditionStmt()
	}
	{
		p.SetState(1250)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1251)
		p.Match(VisualBasic6ParserTHEN)
	}
	p.SetState(1253)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1252)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1255)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1263)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1257)
			p.Block()
		}
		p.SetState(1259)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1258)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1261)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IIfElseBlockStmtContext is an interface to support dynamic dispatch.
type IIfElseBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfElseBlockStmtContext differentiates from other interfaces.
	IsIfElseBlockStmtContext()
}

type IfElseBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfElseBlockStmtContext() *IfElseBlockStmtContext {
	var p = new(IfElseBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ifElseBlockStmt
	return p
}

func (*IfElseBlockStmtContext) IsIfElseBlockStmtContext() {}

func NewIfElseBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfElseBlockStmtContext {
	var p = new(IfElseBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ifElseBlockStmt

	return p
}

func (s *IfElseBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *IfElseBlockStmtContext) ELSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSE, 0)
}

func (s *IfElseBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *IfElseBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *IfElseBlockStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *IfElseBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfElseBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfElseBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterIfElseBlockStmt(s)
	}
}

func (s *IfElseBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitIfElseBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) IfElseBlockStmt() (localctx IIfElseBlockStmtContext) {
	this := p
	_ = this

	localctx = NewIfElseBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, VisualBasic6ParserRULE_ifElseBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1265)
		p.Match(VisualBasic6ParserELSE)
	}
	p.SetState(1267)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1266)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1269)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1277)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1271)
			p.Block()
		}
		p.SetState(1273)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1272)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1275)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IImplementsStmtContext is an interface to support dynamic dispatch.
type IImplementsStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsImplementsStmtContext differentiates from other interfaces.
	IsImplementsStmtContext()
}

type ImplementsStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImplementsStmtContext() *ImplementsStmtContext {
	var p = new(ImplementsStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_implementsStmt
	return p
}

func (*ImplementsStmtContext) IsImplementsStmtContext() {}

func NewImplementsStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplementsStmtContext {
	var p = new(ImplementsStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_implementsStmt

	return p
}

func (s *ImplementsStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ImplementsStmtContext) IMPLEMENTS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIMPLEMENTS, 0)
}

func (s *ImplementsStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ImplementsStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ImplementsStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImplementsStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImplementsStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterImplementsStmt(s)
	}
}

func (s *ImplementsStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitImplementsStmt(s)
	}
}

func (p *VisualBasic6Parser) ImplementsStmt() (localctx IImplementsStmtContext) {
	this := p
	_ = this

	localctx = NewImplementsStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, VisualBasic6ParserRULE_implementsStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1279)
		p.Match(VisualBasic6ParserIMPLEMENTS)
	}
	{
		p.SetState(1280)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1281)
		p.AmbiguousIdentifier()
	}

	return localctx
}

// IInputStmtContext is an interface to support dynamic dispatch.
type IInputStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInputStmtContext differentiates from other interfaces.
	IsInputStmtContext()
}

type InputStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInputStmtContext() *InputStmtContext {
	var p = new(InputStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_inputStmt
	return p
}

func (*InputStmtContext) IsInputStmtContext() {}

func NewInputStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InputStmtContext {
	var p = new(InputStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_inputStmt

	return p
}

func (s *InputStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *InputStmtContext) INPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINPUT, 0)
}

func (s *InputStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *InputStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *InputStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *InputStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *InputStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *InputStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *InputStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InputStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InputStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterInputStmt(s)
	}
}

func (s *InputStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitInputStmt(s)
	}
}

func (p *VisualBasic6Parser) InputStmt() (localctx IInputStmtContext) {
	this := p
	_ = this

	localctx = NewInputStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, VisualBasic6ParserRULE_inputStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1283)
		p.Match(VisualBasic6ParserINPUT)
	}
	{
		p.SetState(1284)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1285)
		p.valueStmt(0)
	}
	p.SetState(1294)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			p.SetState(1287)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1286)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1289)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(1291)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 169, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1290)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1293)
				p.valueStmt(0)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(1296)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 170, p.GetParserRuleContext())
	}

	return localctx
}

// IKillStmtContext is an interface to support dynamic dispatch.
type IKillStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKillStmtContext differentiates from other interfaces.
	IsKillStmtContext()
}

type KillStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKillStmtContext() *KillStmtContext {
	var p = new(KillStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_killStmt
	return p
}

func (*KillStmtContext) IsKillStmtContext() {}

func NewKillStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KillStmtContext {
	var p = new(KillStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_killStmt

	return p
}

func (s *KillStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *KillStmtContext) KILL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserKILL, 0)
}

func (s *KillStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *KillStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *KillStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KillStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KillStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterKillStmt(s)
	}
}

func (s *KillStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitKillStmt(s)
	}
}

func (p *VisualBasic6Parser) KillStmt() (localctx IKillStmtContext) {
	this := p
	_ = this

	localctx = NewKillStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, VisualBasic6ParserRULE_killStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1298)
		p.Match(VisualBasic6ParserKILL)
	}
	{
		p.SetState(1299)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1300)
		p.valueStmt(0)
	}

	return localctx
}

// ILetStmtContext is an interface to support dynamic dispatch.
type ILetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLetStmtContext differentiates from other interfaces.
	IsLetStmtContext()
}

type LetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLetStmtContext() *LetStmtContext {
	var p = new(LetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_letStmt
	return p
}

func (*LetStmtContext) IsLetStmtContext() {}

func NewLetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LetStmtContext {
	var p = new(LetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_letStmt

	return p
}

func (s *LetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LetStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *LetStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *LetStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *LetStmtContext) PLUS_EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPLUS_EQ, 0)
}

func (s *LetStmtContext) MINUS_EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMINUS_EQ, 0)
}

func (s *LetStmtContext) LET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLET, 0)
}

func (s *LetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *LetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *LetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLetStmt(s)
	}
}

func (s *LetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLetStmt(s)
	}
}

func (p *VisualBasic6Parser) LetStmt() (localctx ILetStmtContext) {
	this := p
	_ = this

	localctx = NewLetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, VisualBasic6ParserRULE_letStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1304)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1302)
			p.Match(VisualBasic6ParserLET)
		}
		{
			p.SetState(1303)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1306)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(1308)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1307)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1310)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-187)&-(0x1f+1)) == 0 && ((1<<uint((_la-187)))&((1<<(VisualBasic6ParserEQ-187))|(1<<(VisualBasic6ParserMINUS_EQ-187))|(1<<(VisualBasic6ParserPLUS_EQ-187)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1312)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 173, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1311)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1314)
		p.valueStmt(0)
	}

	return localctx
}

// ILineInputStmtContext is an interface to support dynamic dispatch.
type ILineInputStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLineInputStmtContext differentiates from other interfaces.
	IsLineInputStmtContext()
}

type LineInputStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLineInputStmtContext() *LineInputStmtContext {
	var p = new(LineInputStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_lineInputStmt
	return p
}

func (*LineInputStmtContext) IsLineInputStmtContext() {}

func NewLineInputStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LineInputStmtContext {
	var p = new(LineInputStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_lineInputStmt

	return p
}

func (s *LineInputStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LineInputStmtContext) LINE_INPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLINE_INPUT, 0)
}

func (s *LineInputStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *LineInputStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *LineInputStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *LineInputStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *LineInputStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *LineInputStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LineInputStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LineInputStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLineInputStmt(s)
	}
}

func (s *LineInputStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLineInputStmt(s)
	}
}

func (p *VisualBasic6Parser) LineInputStmt() (localctx ILineInputStmtContext) {
	this := p
	_ = this

	localctx = NewLineInputStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, VisualBasic6ParserRULE_lineInputStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1316)
		p.Match(VisualBasic6ParserLINE_INPUT)
	}
	{
		p.SetState(1317)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1318)
		p.valueStmt(0)
	}
	p.SetState(1320)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1319)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1322)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1324)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 175, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1323)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1326)
		p.valueStmt(0)
	}

	return localctx
}

// ILoadStmtContext is an interface to support dynamic dispatch.
type ILoadStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLoadStmtContext differentiates from other interfaces.
	IsLoadStmtContext()
}

type LoadStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLoadStmtContext() *LoadStmtContext {
	var p = new(LoadStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_loadStmt
	return p
}

func (*LoadStmtContext) IsLoadStmtContext() {}

func NewLoadStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadStmtContext {
	var p = new(LoadStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_loadStmt

	return p
}

func (s *LoadStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LoadStmtContext) LOAD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOAD, 0)
}

func (s *LoadStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *LoadStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *LoadStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LoadStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LoadStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLoadStmt(s)
	}
}

func (s *LoadStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLoadStmt(s)
	}
}

func (p *VisualBasic6Parser) LoadStmt() (localctx ILoadStmtContext) {
	this := p
	_ = this

	localctx = NewLoadStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, VisualBasic6ParserRULE_loadStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1328)
		p.Match(VisualBasic6ParserLOAD)
	}
	{
		p.SetState(1329)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1330)
		p.valueStmt(0)
	}

	return localctx
}

// ILockStmtContext is an interface to support dynamic dispatch.
type ILockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLockStmtContext differentiates from other interfaces.
	IsLockStmtContext()
}

type LockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLockStmtContext() *LockStmtContext {
	var p = new(LockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_lockStmt
	return p
}

func (*LockStmtContext) IsLockStmtContext() {}

func NewLockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockStmtContext {
	var p = new(LockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_lockStmt

	return p
}

func (s *LockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LockStmtContext) LOCK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOCK, 0)
}

func (s *LockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *LockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *LockStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *LockStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *LockStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *LockStmtContext) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *LockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLockStmt(s)
	}
}

func (s *LockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLockStmt(s)
	}
}

func (p *VisualBasic6Parser) LockStmt() (localctx ILockStmtContext) {
	this := p
	_ = this

	localctx = NewLockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, VisualBasic6ParserRULE_lockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1332)
		p.Match(VisualBasic6ParserLOCK)
	}
	{
		p.SetState(1333)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1334)
		p.valueStmt(0)
	}
	p.SetState(1349)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 179, p.GetParserRuleContext()) == 1 {
		p.SetState(1336)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1335)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1338)
			p.Match(VisualBasic6ParserCOMMA)
		}
		p.SetState(1340)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 177, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1339)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1342)
			p.valueStmt(0)
		}
		p.SetState(1347)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 178, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1343)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(1344)
				p.Match(VisualBasic6ParserTO)
			}
			{
				p.SetState(1345)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(1346)
				p.valueStmt(0)
			}

		}

	}

	return localctx
}

// ILsetStmtContext is an interface to support dynamic dispatch.
type ILsetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLsetStmtContext differentiates from other interfaces.
	IsLsetStmtContext()
}

type LsetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLsetStmtContext() *LsetStmtContext {
	var p = new(LsetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_lsetStmt
	return p
}

func (*LsetStmtContext) IsLsetStmtContext() {}

func NewLsetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LsetStmtContext {
	var p = new(LsetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_lsetStmt

	return p
}

func (s *LsetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *LsetStmtContext) LSET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLSET, 0)
}

func (s *LsetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *LsetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *LsetStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *LsetStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *LsetStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *LsetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LsetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LsetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLsetStmt(s)
	}
}

func (s *LsetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLsetStmt(s)
	}
}

func (p *VisualBasic6Parser) LsetStmt() (localctx ILsetStmtContext) {
	this := p
	_ = this

	localctx = NewLsetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, VisualBasic6ParserRULE_lsetStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1351)
		p.Match(VisualBasic6ParserLSET)
	}
	{
		p.SetState(1352)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1353)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(1355)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1354)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1357)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(1359)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1358)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1361)
		p.valueStmt(0)
	}

	return localctx
}

// IMacroIfThenElseStmtContext is an interface to support dynamic dispatch.
type IMacroIfThenElseStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMacroIfThenElseStmtContext differentiates from other interfaces.
	IsMacroIfThenElseStmtContext()
}

type MacroIfThenElseStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMacroIfThenElseStmtContext() *MacroIfThenElseStmtContext {
	var p = new(MacroIfThenElseStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_macroIfThenElseStmt
	return p
}

func (*MacroIfThenElseStmtContext) IsMacroIfThenElseStmtContext() {}

func NewMacroIfThenElseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MacroIfThenElseStmtContext {
	var p = new(MacroIfThenElseStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_macroIfThenElseStmt

	return p
}

func (s *MacroIfThenElseStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MacroIfThenElseStmtContext) MacroIfBlockStmt() IMacroIfBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMacroIfBlockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMacroIfBlockStmtContext)
}

func (s *MacroIfThenElseStmtContext) MACRO_END_IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMACRO_END_IF, 0)
}

func (s *MacroIfThenElseStmtContext) AllMacroElseIfBlockStmt() []IMacroElseIfBlockStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMacroElseIfBlockStmtContext)(nil)).Elem())
	var tst = make([]IMacroElseIfBlockStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IMacroElseIfBlockStmtContext)
		}
	}

	return tst
}

func (s *MacroIfThenElseStmtContext) MacroElseIfBlockStmt(i int) IMacroElseIfBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMacroElseIfBlockStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IMacroElseIfBlockStmtContext)
}

func (s *MacroIfThenElseStmtContext) MacroElseBlockStmt() IMacroElseBlockStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMacroElseBlockStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMacroElseBlockStmtContext)
}

func (s *MacroIfThenElseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MacroIfThenElseStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MacroIfThenElseStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMacroIfThenElseStmt(s)
	}
}

func (s *MacroIfThenElseStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMacroIfThenElseStmt(s)
	}
}

func (p *VisualBasic6Parser) MacroIfThenElseStmt() (localctx IMacroIfThenElseStmtContext) {
	this := p
	_ = this

	localctx = NewMacroIfThenElseStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, VisualBasic6ParserRULE_macroIfThenElseStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1363)
		p.MacroIfBlockStmt()
	}
	p.SetState(1367)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == VisualBasic6ParserMACRO_ELSEIF {
		{
			p.SetState(1364)
			p.MacroElseIfBlockStmt()
		}

		p.SetState(1369)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1371)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserMACRO_ELSE {
		{
			p.SetState(1370)
			p.MacroElseBlockStmt()
		}

	}
	{
		p.SetState(1373)
		p.Match(VisualBasic6ParserMACRO_END_IF)
	}

	return localctx
}

// IMacroIfBlockStmtContext is an interface to support dynamic dispatch.
type IMacroIfBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMacroIfBlockStmtContext differentiates from other interfaces.
	IsMacroIfBlockStmtContext()
}

type MacroIfBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMacroIfBlockStmtContext() *MacroIfBlockStmtContext {
	var p = new(MacroIfBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_macroIfBlockStmt
	return p
}

func (*MacroIfBlockStmtContext) IsMacroIfBlockStmtContext() {}

func NewMacroIfBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MacroIfBlockStmtContext {
	var p = new(MacroIfBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_macroIfBlockStmt

	return p
}

func (s *MacroIfBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MacroIfBlockStmtContext) MACRO_IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMACRO_IF, 0)
}

func (s *MacroIfBlockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *MacroIfBlockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *MacroIfBlockStmtContext) IfConditionStmt() IIfConditionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionStmtContext)
}

func (s *MacroIfBlockStmtContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *MacroIfBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *MacroIfBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *MacroIfBlockStmtContext) ModuleBody() IModuleBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyContext)
}

func (s *MacroIfBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MacroIfBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MacroIfBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMacroIfBlockStmt(s)
	}
}

func (s *MacroIfBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMacroIfBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) MacroIfBlockStmt() (localctx IMacroIfBlockStmtContext) {
	this := p
	_ = this

	localctx = NewMacroIfBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, VisualBasic6ParserRULE_macroIfBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1375)
		p.Match(VisualBasic6ParserMACRO_IF)
	}
	{
		p.SetState(1376)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1377)
		p.IfConditionStmt()
	}
	{
		p.SetState(1378)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1379)
		p.Match(VisualBasic6ParserTHEN)
	}
	p.SetState(1381)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1380)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1383)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1391)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOPTION_BASE-96))|(1<<(VisualBasic6ParserOPTION_EXPLICIT-96))|(1<<(VisualBasic6ParserOPTION_COMPARE-96))|(1<<(VisualBasic6ParserOPTION_PRIVATE_MODULE-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96))|(1<<(VisualBasic6ParserPROPERTY_GET-96))|(1<<(VisualBasic6ParserPROPERTY_LET-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(VisualBasic6ParserPROPERTY_SET-128))|(1<<(VisualBasic6ParserPUBLIC-128))|(1<<(VisualBasic6ParserPUT-128))|(1<<(VisualBasic6ParserRANDOM-128))|(1<<(VisualBasic6ParserRANDOMIZE-128))|(1<<(VisualBasic6ParserRAISEEVENT-128))|(1<<(VisualBasic6ParserREAD-128))|(1<<(VisualBasic6ParserREDIM-128))|(1<<(VisualBasic6ParserREM-128))|(1<<(VisualBasic6ParserRESET-128))|(1<<(VisualBasic6ParserRESUME-128))|(1<<(VisualBasic6ParserRETURN-128))|(1<<(VisualBasic6ParserRMDIR-128))|(1<<(VisualBasic6ParserRSET-128))|(1<<(VisualBasic6ParserSAVEPICTURE-128))|(1<<(VisualBasic6ParserSAVESETTING-128))|(1<<(VisualBasic6ParserSEEK-128))|(1<<(VisualBasic6ParserSELECT-128))|(1<<(VisualBasic6ParserSENDKEYS-128))|(1<<(VisualBasic6ParserSET-128))|(1<<(VisualBasic6ParserSETATTR-128))|(1<<(VisualBasic6ParserSHARED-128))|(1<<(VisualBasic6ParserSINGLE-128))|(1<<(VisualBasic6ParserSPC-128))|(1<<(VisualBasic6ParserSTATIC-128))|(1<<(VisualBasic6ParserSTEP-128))|(1<<(VisualBasic6ParserSTOP-128))|(1<<(VisualBasic6ParserSTRING-128))|(1<<(VisualBasic6ParserSUB-128))|(1<<(VisualBasic6ParserTAB-128))|(1<<(VisualBasic6ParserTEXT-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(VisualBasic6ParserTHEN-160))|(1<<(VisualBasic6ParserTIME-160))|(1<<(VisualBasic6ParserTO-160))|(1<<(VisualBasic6ParserTRUE-160))|(1<<(VisualBasic6ParserTYPE-160))|(1<<(VisualBasic6ParserTYPEOF-160))|(1<<(VisualBasic6ParserUNLOAD-160))|(1<<(VisualBasic6ParserUNLOCK-160))|(1<<(VisualBasic6ParserUNTIL-160))|(1<<(VisualBasic6ParserVARIANT-160))|(1<<(VisualBasic6ParserVERSION-160))|(1<<(VisualBasic6ParserWEND-160))|(1<<(VisualBasic6ParserWHILE-160))|(1<<(VisualBasic6ParserWIDTH-160))|(1<<(VisualBasic6ParserWITH-160))|(1<<(VisualBasic6ParserWITHEVENTS-160))|(1<<(VisualBasic6ParserWRITE-160))|(1<<(VisualBasic6ParserXOR-160))|(1<<(VisualBasic6ParserDOT-160))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-160)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1385)
			p.ModuleBody()
		}
		p.SetState(1387)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1386)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1389)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IMacroElseIfBlockStmtContext is an interface to support dynamic dispatch.
type IMacroElseIfBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMacroElseIfBlockStmtContext differentiates from other interfaces.
	IsMacroElseIfBlockStmtContext()
}

type MacroElseIfBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMacroElseIfBlockStmtContext() *MacroElseIfBlockStmtContext {
	var p = new(MacroElseIfBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_macroElseIfBlockStmt
	return p
}

func (*MacroElseIfBlockStmtContext) IsMacroElseIfBlockStmtContext() {}

func NewMacroElseIfBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MacroElseIfBlockStmtContext {
	var p = new(MacroElseIfBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_macroElseIfBlockStmt

	return p
}

func (s *MacroElseIfBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MacroElseIfBlockStmtContext) MACRO_ELSEIF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMACRO_ELSEIF, 0)
}

func (s *MacroElseIfBlockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *MacroElseIfBlockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *MacroElseIfBlockStmtContext) IfConditionStmt() IIfConditionStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionStmtContext)
}

func (s *MacroElseIfBlockStmtContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *MacroElseIfBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *MacroElseIfBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *MacroElseIfBlockStmtContext) ModuleBody() IModuleBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyContext)
}

func (s *MacroElseIfBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MacroElseIfBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MacroElseIfBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMacroElseIfBlockStmt(s)
	}
}

func (s *MacroElseIfBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMacroElseIfBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) MacroElseIfBlockStmt() (localctx IMacroElseIfBlockStmtContext) {
	this := p
	_ = this

	localctx = NewMacroElseIfBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, VisualBasic6ParserRULE_macroElseIfBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1393)
		p.Match(VisualBasic6ParserMACRO_ELSEIF)
	}
	{
		p.SetState(1394)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1395)
		p.IfConditionStmt()
	}
	{
		p.SetState(1396)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1397)
		p.Match(VisualBasic6ParserTHEN)
	}
	p.SetState(1399)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1398)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1401)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1409)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOPTION_BASE-96))|(1<<(VisualBasic6ParserOPTION_EXPLICIT-96))|(1<<(VisualBasic6ParserOPTION_COMPARE-96))|(1<<(VisualBasic6ParserOPTION_PRIVATE_MODULE-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96))|(1<<(VisualBasic6ParserPROPERTY_GET-96))|(1<<(VisualBasic6ParserPROPERTY_LET-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(VisualBasic6ParserPROPERTY_SET-128))|(1<<(VisualBasic6ParserPUBLIC-128))|(1<<(VisualBasic6ParserPUT-128))|(1<<(VisualBasic6ParserRANDOM-128))|(1<<(VisualBasic6ParserRANDOMIZE-128))|(1<<(VisualBasic6ParserRAISEEVENT-128))|(1<<(VisualBasic6ParserREAD-128))|(1<<(VisualBasic6ParserREDIM-128))|(1<<(VisualBasic6ParserREM-128))|(1<<(VisualBasic6ParserRESET-128))|(1<<(VisualBasic6ParserRESUME-128))|(1<<(VisualBasic6ParserRETURN-128))|(1<<(VisualBasic6ParserRMDIR-128))|(1<<(VisualBasic6ParserRSET-128))|(1<<(VisualBasic6ParserSAVEPICTURE-128))|(1<<(VisualBasic6ParserSAVESETTING-128))|(1<<(VisualBasic6ParserSEEK-128))|(1<<(VisualBasic6ParserSELECT-128))|(1<<(VisualBasic6ParserSENDKEYS-128))|(1<<(VisualBasic6ParserSET-128))|(1<<(VisualBasic6ParserSETATTR-128))|(1<<(VisualBasic6ParserSHARED-128))|(1<<(VisualBasic6ParserSINGLE-128))|(1<<(VisualBasic6ParserSPC-128))|(1<<(VisualBasic6ParserSTATIC-128))|(1<<(VisualBasic6ParserSTEP-128))|(1<<(VisualBasic6ParserSTOP-128))|(1<<(VisualBasic6ParserSTRING-128))|(1<<(VisualBasic6ParserSUB-128))|(1<<(VisualBasic6ParserTAB-128))|(1<<(VisualBasic6ParserTEXT-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(VisualBasic6ParserTHEN-160))|(1<<(VisualBasic6ParserTIME-160))|(1<<(VisualBasic6ParserTO-160))|(1<<(VisualBasic6ParserTRUE-160))|(1<<(VisualBasic6ParserTYPE-160))|(1<<(VisualBasic6ParserTYPEOF-160))|(1<<(VisualBasic6ParserUNLOAD-160))|(1<<(VisualBasic6ParserUNLOCK-160))|(1<<(VisualBasic6ParserUNTIL-160))|(1<<(VisualBasic6ParserVARIANT-160))|(1<<(VisualBasic6ParserVERSION-160))|(1<<(VisualBasic6ParserWEND-160))|(1<<(VisualBasic6ParserWHILE-160))|(1<<(VisualBasic6ParserWIDTH-160))|(1<<(VisualBasic6ParserWITH-160))|(1<<(VisualBasic6ParserWITHEVENTS-160))|(1<<(VisualBasic6ParserWRITE-160))|(1<<(VisualBasic6ParserXOR-160))|(1<<(VisualBasic6ParserDOT-160))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-160)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1403)
			p.ModuleBody()
		}
		p.SetState(1405)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1404)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1407)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IMacroElseBlockStmtContext is an interface to support dynamic dispatch.
type IMacroElseBlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMacroElseBlockStmtContext differentiates from other interfaces.
	IsMacroElseBlockStmtContext()
}

type MacroElseBlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMacroElseBlockStmtContext() *MacroElseBlockStmtContext {
	var p = new(MacroElseBlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_macroElseBlockStmt
	return p
}

func (*MacroElseBlockStmtContext) IsMacroElseBlockStmtContext() {}

func NewMacroElseBlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MacroElseBlockStmtContext {
	var p = new(MacroElseBlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_macroElseBlockStmt

	return p
}

func (s *MacroElseBlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MacroElseBlockStmtContext) MACRO_ELSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMACRO_ELSE, 0)
}

func (s *MacroElseBlockStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *MacroElseBlockStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *MacroElseBlockStmtContext) ModuleBody() IModuleBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyContext)
}

func (s *MacroElseBlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MacroElseBlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MacroElseBlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMacroElseBlockStmt(s)
	}
}

func (s *MacroElseBlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMacroElseBlockStmt(s)
	}
}

func (p *VisualBasic6Parser) MacroElseBlockStmt() (localctx IMacroElseBlockStmtContext) {
	this := p
	_ = this

	localctx = NewMacroElseBlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, VisualBasic6ParserRULE_macroElseBlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1411)
		p.Match(VisualBasic6ParserMACRO_ELSE)
	}
	p.SetState(1413)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1412)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1415)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1423)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOPTION_BASE-96))|(1<<(VisualBasic6ParserOPTION_EXPLICIT-96))|(1<<(VisualBasic6ParserOPTION_COMPARE-96))|(1<<(VisualBasic6ParserOPTION_PRIVATE_MODULE-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96))|(1<<(VisualBasic6ParserPROPERTY_GET-96))|(1<<(VisualBasic6ParserPROPERTY_LET-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(VisualBasic6ParserPROPERTY_SET-128))|(1<<(VisualBasic6ParserPUBLIC-128))|(1<<(VisualBasic6ParserPUT-128))|(1<<(VisualBasic6ParserRANDOM-128))|(1<<(VisualBasic6ParserRANDOMIZE-128))|(1<<(VisualBasic6ParserRAISEEVENT-128))|(1<<(VisualBasic6ParserREAD-128))|(1<<(VisualBasic6ParserREDIM-128))|(1<<(VisualBasic6ParserREM-128))|(1<<(VisualBasic6ParserRESET-128))|(1<<(VisualBasic6ParserRESUME-128))|(1<<(VisualBasic6ParserRETURN-128))|(1<<(VisualBasic6ParserRMDIR-128))|(1<<(VisualBasic6ParserRSET-128))|(1<<(VisualBasic6ParserSAVEPICTURE-128))|(1<<(VisualBasic6ParserSAVESETTING-128))|(1<<(VisualBasic6ParserSEEK-128))|(1<<(VisualBasic6ParserSELECT-128))|(1<<(VisualBasic6ParserSENDKEYS-128))|(1<<(VisualBasic6ParserSET-128))|(1<<(VisualBasic6ParserSETATTR-128))|(1<<(VisualBasic6ParserSHARED-128))|(1<<(VisualBasic6ParserSINGLE-128))|(1<<(VisualBasic6ParserSPC-128))|(1<<(VisualBasic6ParserSTATIC-128))|(1<<(VisualBasic6ParserSTEP-128))|(1<<(VisualBasic6ParserSTOP-128))|(1<<(VisualBasic6ParserSTRING-128))|(1<<(VisualBasic6ParserSUB-128))|(1<<(VisualBasic6ParserTAB-128))|(1<<(VisualBasic6ParserTEXT-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(VisualBasic6ParserTHEN-160))|(1<<(VisualBasic6ParserTIME-160))|(1<<(VisualBasic6ParserTO-160))|(1<<(VisualBasic6ParserTRUE-160))|(1<<(VisualBasic6ParserTYPE-160))|(1<<(VisualBasic6ParserTYPEOF-160))|(1<<(VisualBasic6ParserUNLOAD-160))|(1<<(VisualBasic6ParserUNLOCK-160))|(1<<(VisualBasic6ParserUNTIL-160))|(1<<(VisualBasic6ParserVARIANT-160))|(1<<(VisualBasic6ParserVERSION-160))|(1<<(VisualBasic6ParserWEND-160))|(1<<(VisualBasic6ParserWHILE-160))|(1<<(VisualBasic6ParserWIDTH-160))|(1<<(VisualBasic6ParserWITH-160))|(1<<(VisualBasic6ParserWITHEVENTS-160))|(1<<(VisualBasic6ParserWRITE-160))|(1<<(VisualBasic6ParserXOR-160))|(1<<(VisualBasic6ParserDOT-160))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-160)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1417)
			p.ModuleBody()
		}
		p.SetState(1419)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1418)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1421)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IMidStmtContext is an interface to support dynamic dispatch.
type IMidStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMidStmtContext differentiates from other interfaces.
	IsMidStmtContext()
}

type MidStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMidStmtContext() *MidStmtContext {
	var p = new(MidStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_midStmt
	return p
}

func (*MidStmtContext) IsMidStmtContext() {}

func NewMidStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MidStmtContext {
	var p = new(MidStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_midStmt

	return p
}

func (s *MidStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MidStmtContext) MID() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMID, 0)
}

func (s *MidStmtContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *MidStmtContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *MidStmtContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *MidStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *MidStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *MidStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MidStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MidStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMidStmt(s)
	}
}

func (s *MidStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMidStmt(s)
	}
}

func (p *VisualBasic6Parser) MidStmt() (localctx IMidStmtContext) {
	this := p
	_ = this

	localctx = NewMidStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, VisualBasic6ParserRULE_midStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1425)
		p.Match(VisualBasic6ParserMID)
	}
	p.SetState(1427)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1426)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1429)
		p.Match(VisualBasic6ParserLPAREN)
	}
	p.SetState(1431)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 194, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1430)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1433)
		p.ArgsCall()
	}
	p.SetState(1435)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1434)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1437)
		p.Match(VisualBasic6ParserRPAREN)
	}

	return localctx
}

// IMkdirStmtContext is an interface to support dynamic dispatch.
type IMkdirStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMkdirStmtContext differentiates from other interfaces.
	IsMkdirStmtContext()
}

type MkdirStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMkdirStmtContext() *MkdirStmtContext {
	var p = new(MkdirStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_mkdirStmt
	return p
}

func (*MkdirStmtContext) IsMkdirStmtContext() {}

func NewMkdirStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MkdirStmtContext {
	var p = new(MkdirStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_mkdirStmt

	return p
}

func (s *MkdirStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *MkdirStmtContext) MKDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMKDIR, 0)
}

func (s *MkdirStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *MkdirStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *MkdirStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MkdirStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MkdirStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterMkdirStmt(s)
	}
}

func (s *MkdirStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitMkdirStmt(s)
	}
}

func (p *VisualBasic6Parser) MkdirStmt() (localctx IMkdirStmtContext) {
	this := p
	_ = this

	localctx = NewMkdirStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, VisualBasic6ParserRULE_mkdirStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1439)
		p.Match(VisualBasic6ParserMKDIR)
	}
	{
		p.SetState(1440)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1441)
		p.valueStmt(0)
	}

	return localctx
}

// INameStmtContext is an interface to support dynamic dispatch.
type INameStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNameStmtContext differentiates from other interfaces.
	IsNameStmtContext()
}

type NameStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNameStmtContext() *NameStmtContext {
	var p = new(NameStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_nameStmt
	return p
}

func (*NameStmtContext) IsNameStmtContext() {}

func NewNameStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameStmtContext {
	var p = new(NameStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_nameStmt

	return p
}

func (s *NameStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *NameStmtContext) NAME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNAME, 0)
}

func (s *NameStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *NameStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *NameStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *NameStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *NameStmtContext) AS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAS, 0)
}

func (s *NameStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NameStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NameStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterNameStmt(s)
	}
}

func (s *NameStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitNameStmt(s)
	}
}

func (p *VisualBasic6Parser) NameStmt() (localctx INameStmtContext) {
	this := p
	_ = this

	localctx = NewNameStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, VisualBasic6ParserRULE_nameStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1443)
		p.Match(VisualBasic6ParserNAME)
	}
	{
		p.SetState(1444)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1445)
		p.valueStmt(0)
	}
	{
		p.SetState(1446)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1447)
		p.Match(VisualBasic6ParserAS)
	}
	{
		p.SetState(1448)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1449)
		p.valueStmt(0)
	}

	return localctx
}

// IOnErrorStmtContext is an interface to support dynamic dispatch.
type IOnErrorStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOnErrorStmtContext differentiates from other interfaces.
	IsOnErrorStmtContext()
}

type OnErrorStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOnErrorStmtContext() *OnErrorStmtContext {
	var p = new(OnErrorStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_onErrorStmt
	return p
}

func (*OnErrorStmtContext) IsOnErrorStmtContext() {}

func NewOnErrorStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OnErrorStmtContext {
	var p = new(OnErrorStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_onErrorStmt

	return p
}

func (s *OnErrorStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *OnErrorStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OnErrorStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OnErrorStmtContext) ON_ERROR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserON_ERROR, 0)
}

func (s *OnErrorStmtContext) ON_LOCAL_ERROR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserON_LOCAL_ERROR, 0)
}

func (s *OnErrorStmtContext) GOTO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOTO, 0)
}

func (s *OnErrorStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *OnErrorStmtContext) RESUME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRESUME, 0)
}

func (s *OnErrorStmtContext) NEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEXT, 0)
}

func (s *OnErrorStmtContext) COLON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLON, 0)
}

func (s *OnErrorStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OnErrorStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OnErrorStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOnErrorStmt(s)
	}
}

func (s *OnErrorStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOnErrorStmt(s)
	}
}

func (p *VisualBasic6Parser) OnErrorStmt() (localctx IOnErrorStmtContext) {
	this := p
	_ = this

	localctx = NewOnErrorStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, VisualBasic6ParserRULE_onErrorStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1451)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserON_ERROR || _la == VisualBasic6ParserON_LOCAL_ERROR) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(1452)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(1462)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserGOTO:
		{
			p.SetState(1453)
			p.Match(VisualBasic6ParserGOTO)
		}
		{
			p.SetState(1454)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1455)
			p.valueStmt(0)
		}
		p.SetState(1457)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserCOLON {
			{
				p.SetState(1456)
				p.Match(VisualBasic6ParserCOLON)
			}

		}

	case VisualBasic6ParserRESUME:
		{
			p.SetState(1459)
			p.Match(VisualBasic6ParserRESUME)
		}
		{
			p.SetState(1460)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1461)
			p.Match(VisualBasic6ParserNEXT)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IOnGoToStmtContext is an interface to support dynamic dispatch.
type IOnGoToStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOnGoToStmtContext differentiates from other interfaces.
	IsOnGoToStmtContext()
}

type OnGoToStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOnGoToStmtContext() *OnGoToStmtContext {
	var p = new(OnGoToStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_onGoToStmt
	return p
}

func (*OnGoToStmtContext) IsOnGoToStmtContext() {}

func NewOnGoToStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OnGoToStmtContext {
	var p = new(OnGoToStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_onGoToStmt

	return p
}

func (s *OnGoToStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *OnGoToStmtContext) ON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserON, 0)
}

func (s *OnGoToStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OnGoToStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OnGoToStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *OnGoToStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *OnGoToStmtContext) GOTO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOTO, 0)
}

func (s *OnGoToStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *OnGoToStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *OnGoToStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OnGoToStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OnGoToStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOnGoToStmt(s)
	}
}

func (s *OnGoToStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOnGoToStmt(s)
	}
}

func (p *VisualBasic6Parser) OnGoToStmt() (localctx IOnGoToStmtContext) {
	this := p
	_ = this

	localctx = NewOnGoToStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, VisualBasic6ParserRULE_onGoToStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1464)
		p.Match(VisualBasic6ParserON)
	}
	{
		p.SetState(1465)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1466)
		p.valueStmt(0)
	}
	{
		p.SetState(1467)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1468)
		p.Match(VisualBasic6ParserGOTO)
	}
	{
		p.SetState(1469)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1470)
		p.valueStmt(0)
	}
	p.SetState(1481)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 200, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(1472)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1471)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1474)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(1476)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 199, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1475)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1478)
				p.valueStmt(0)
			}

		}
		p.SetState(1483)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 200, p.GetParserRuleContext())
	}

	return localctx
}

// IOnGoSubStmtContext is an interface to support dynamic dispatch.
type IOnGoSubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOnGoSubStmtContext differentiates from other interfaces.
	IsOnGoSubStmtContext()
}

type OnGoSubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOnGoSubStmtContext() *OnGoSubStmtContext {
	var p = new(OnGoSubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_onGoSubStmt
	return p
}

func (*OnGoSubStmtContext) IsOnGoSubStmtContext() {}

func NewOnGoSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OnGoSubStmtContext {
	var p = new(OnGoSubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_onGoSubStmt

	return p
}

func (s *OnGoSubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *OnGoSubStmtContext) ON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserON, 0)
}

func (s *OnGoSubStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OnGoSubStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OnGoSubStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *OnGoSubStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *OnGoSubStmtContext) GOSUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOSUB, 0)
}

func (s *OnGoSubStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *OnGoSubStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *OnGoSubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OnGoSubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OnGoSubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOnGoSubStmt(s)
	}
}

func (s *OnGoSubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOnGoSubStmt(s)
	}
}

func (p *VisualBasic6Parser) OnGoSubStmt() (localctx IOnGoSubStmtContext) {
	this := p
	_ = this

	localctx = NewOnGoSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, VisualBasic6ParserRULE_onGoSubStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1484)
		p.Match(VisualBasic6ParserON)
	}
	{
		p.SetState(1485)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1486)
		p.valueStmt(0)
	}
	{
		p.SetState(1487)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1488)
		p.Match(VisualBasic6ParserGOSUB)
	}
	{
		p.SetState(1489)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1490)
		p.valueStmt(0)
	}
	p.SetState(1501)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(1492)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1491)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1494)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(1496)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1495)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1498)
				p.valueStmt(0)
			}

		}
		p.SetState(1503)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext())
	}

	return localctx
}

// IOpenStmtContext is an interface to support dynamic dispatch.
type IOpenStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOpenStmtContext differentiates from other interfaces.
	IsOpenStmtContext()
}

type OpenStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOpenStmtContext() *OpenStmtContext {
	var p = new(OpenStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_openStmt
	return p
}

func (*OpenStmtContext) IsOpenStmtContext() {}

func NewOpenStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpenStmtContext {
	var p = new(OpenStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_openStmt

	return p
}

func (s *OpenStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *OpenStmtContext) OPEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPEN, 0)
}

func (s *OpenStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OpenStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OpenStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *OpenStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *OpenStmtContext) FOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFOR, 0)
}

func (s *OpenStmtContext) AS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAS, 0)
}

func (s *OpenStmtContext) APPEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAPPEND, 0)
}

func (s *OpenStmtContext) BINARY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBINARY, 0)
}

func (s *OpenStmtContext) INPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINPUT, 0)
}

func (s *OpenStmtContext) OUTPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOUTPUT, 0)
}

func (s *OpenStmtContext) RANDOM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRANDOM, 0)
}

func (s *OpenStmtContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserACCESS, 0)
}

func (s *OpenStmtContext) LEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLEN, 0)
}

func (s *OpenStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *OpenStmtContext) READ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREAD, 0)
}

func (s *OpenStmtContext) WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWRITE, 0)
}

func (s *OpenStmtContext) READ_WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREAD_WRITE, 0)
}

func (s *OpenStmtContext) SHARED() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSHARED, 0)
}

func (s *OpenStmtContext) LOCK_READ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOCK_READ, 0)
}

func (s *OpenStmtContext) LOCK_WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOCK_WRITE, 0)
}

func (s *OpenStmtContext) LOCK_READ_WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOCK_READ_WRITE, 0)
}

func (s *OpenStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OpenStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OpenStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOpenStmt(s)
	}
}

func (s *OpenStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOpenStmt(s)
	}
}

func (p *VisualBasic6Parser) OpenStmt() (localctx IOpenStmtContext) {
	this := p
	_ = this

	localctx = NewOpenStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, VisualBasic6ParserRULE_openStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1504)
		p.Match(VisualBasic6ParserOPEN)
	}
	{
		p.SetState(1505)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1506)
		p.valueStmt(0)
	}
	{
		p.SetState(1507)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1508)
		p.Match(VisualBasic6ParserFOR)
	}
	{
		p.SetState(1509)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1510)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserAPPEND || _la == VisualBasic6ParserBINARY || _la == VisualBasic6ParserINPUT || _la == VisualBasic6ParserOUTPUT || _la == VisualBasic6ParserRANDOM) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1515)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 204, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1511)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1512)
			p.Match(VisualBasic6ParserACCESS)
		}
		{
			p.SetState(1513)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1514)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserREAD || _la == VisualBasic6ParserREAD_WRITE || _la == VisualBasic6ParserWRITE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	p.SetState(1519)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 205, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1517)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1518)
			_la = p.GetTokenStream().LA(1)

			if !((((_la-92)&-(0x1f+1)) == 0 && ((1<<uint((_la-92)))&((1<<(VisualBasic6ParserLOCK_READ-92))|(1<<(VisualBasic6ParserLOCK_WRITE-92))|(1<<(VisualBasic6ParserLOCK_READ_WRITE-92)))) != 0) || _la == VisualBasic6ParserSHARED) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	{
		p.SetState(1521)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1522)
		p.Match(VisualBasic6ParserAS)
	}
	{
		p.SetState(1523)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1524)
		p.valueStmt(0)
	}
	p.SetState(1535)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 208, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1525)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1526)
			p.Match(VisualBasic6ParserLEN)
		}
		p.SetState(1528)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1527)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1530)
			p.Match(VisualBasic6ParserEQ)
		}
		p.SetState(1532)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 207, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1531)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1534)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IOutputListContext is an interface to support dynamic dispatch.
type IOutputListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOutputListContext differentiates from other interfaces.
	IsOutputListContext()
}

type OutputListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOutputListContext() *OutputListContext {
	var p = new(OutputListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_outputList
	return p
}

func (*OutputListContext) IsOutputListContext() {}

func NewOutputListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OutputListContext {
	var p = new(OutputListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_outputList

	return p
}

func (s *OutputListContext) GetParser() antlr.Parser { return s.parser }

func (s *OutputListContext) AllOutputList_Expression() []IOutputList_ExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOutputList_ExpressionContext)(nil)).Elem())
	var tst = make([]IOutputList_ExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IOutputList_ExpressionContext)
		}
	}

	return tst
}

func (s *OutputListContext) OutputList_Expression(i int) IOutputList_ExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOutputList_ExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOutputList_ExpressionContext)
}

func (s *OutputListContext) AllSEMICOLON() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserSEMICOLON)
}

func (s *OutputListContext) SEMICOLON(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSEMICOLON, i)
}

func (s *OutputListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *OutputListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *OutputListContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OutputListContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OutputListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OutputListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OutputListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOutputList(s)
	}
}

func (s *OutputListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOutputList(s)
	}
}

func (p *VisualBasic6Parser) OutputList() (localctx IOutputListContext) {
	this := p
	_ = this

	localctx = NewOutputListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, VisualBasic6ParserRULE_outputList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.SetState(1570)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 218, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1537)
			p.OutputList_Expression()
		}
		p.SetState(1550)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 212, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(1539)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(1538)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(1541)
					_la = p.GetTokenStream().LA(1)

					if !(_la == VisualBasic6ParserCOMMA || _la == VisualBasic6ParserSEMICOLON) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(1543)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 210, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1542)
						p.Match(VisualBasic6ParserWS)
					}

				}
				p.SetState(1546)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 211, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1545)
						p.OutputList_Expression()
					}

				}

			}
			p.SetState(1552)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 212, p.GetParserRuleContext())
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1554)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 213, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1553)
				p.OutputList_Expression()
			}

		}
		p.SetState(1566)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
				p.SetState(1557)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(1556)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(1559)
					_la = p.GetTokenStream().LA(1)

					if !(_la == VisualBasic6ParserCOMMA || _la == VisualBasic6ParserSEMICOLON) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(1561)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 215, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1560)
						p.Match(VisualBasic6ParserWS)
					}

				}
				p.SetState(1564)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 216, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1563)
						p.OutputList_Expression()
					}

				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

			p.SetState(1568)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 217, p.GetParserRuleContext())
		}

	}

	return localctx
}

// IOutputList_ExpressionContext is an interface to support dynamic dispatch.
type IOutputList_ExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOutputList_ExpressionContext differentiates from other interfaces.
	IsOutputList_ExpressionContext()
}

type OutputList_ExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOutputList_ExpressionContext() *OutputList_ExpressionContext {
	var p = new(OutputList_ExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_outputList_Expression
	return p
}

func (*OutputList_ExpressionContext) IsOutputList_ExpressionContext() {}

func NewOutputList_ExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OutputList_ExpressionContext {
	var p = new(OutputList_ExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_outputList_Expression

	return p
}

func (s *OutputList_ExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *OutputList_ExpressionContext) SPC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSPC, 0)
}

func (s *OutputList_ExpressionContext) TAB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTAB, 0)
}

func (s *OutputList_ExpressionContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *OutputList_ExpressionContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *OutputList_ExpressionContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *OutputList_ExpressionContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *OutputList_ExpressionContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *OutputList_ExpressionContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *OutputList_ExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OutputList_ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OutputList_ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterOutputList_Expression(s)
	}
}

func (s *OutputList_ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitOutputList_Expression(s)
	}
}

func (p *VisualBasic6Parser) OutputList_Expression() (localctx IOutputList_ExpressionContext) {
	this := p
	_ = this

	localctx = NewOutputList_ExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, VisualBasic6ParserRULE_outputList_Expression)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1589)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 223, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1572)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserSPC || _la == VisualBasic6ParserTAB) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(1586)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 222, p.GetParserRuleContext()) == 1 {
			p.SetState(1574)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1573)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1576)
				p.Match(VisualBasic6ParserLPAREN)
			}
			p.SetState(1578)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 220, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1577)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1580)
				p.ArgsCall()
			}
			p.SetState(1582)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1581)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1584)
				p.Match(VisualBasic6ParserRPAREN)
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1588)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IPrintStmtContext is an interface to support dynamic dispatch.
type IPrintStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrintStmtContext differentiates from other interfaces.
	IsPrintStmtContext()
}

type PrintStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrintStmtContext() *PrintStmtContext {
	var p = new(PrintStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_printStmt
	return p
}

func (*PrintStmtContext) IsPrintStmtContext() {}

func NewPrintStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrintStmtContext {
	var p = new(PrintStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_printStmt

	return p
}

func (s *PrintStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PrintStmtContext) PRINT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRINT, 0)
}

func (s *PrintStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *PrintStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *PrintStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *PrintStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *PrintStmtContext) OutputList() IOutputListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOutputListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOutputListContext)
}

func (s *PrintStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrintStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrintStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPrintStmt(s)
	}
}

func (s *PrintStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPrintStmt(s)
	}
}

func (p *VisualBasic6Parser) PrintStmt() (localctx IPrintStmtContext) {
	this := p
	_ = this

	localctx = NewPrintStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, VisualBasic6ParserRULE_printStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1591)
		p.Match(VisualBasic6ParserPRINT)
	}
	{
		p.SetState(1592)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1593)
		p.valueStmt(0)
	}
	p.SetState(1595)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1594)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1597)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1602)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 {
		p.SetState(1599)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1598)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1601)
			p.OutputList()
		}

	}

	return localctx
}

// IPropertyGetStmtContext is an interface to support dynamic dispatch.
type IPropertyGetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyGetStmtContext differentiates from other interfaces.
	IsPropertyGetStmtContext()
}

type PropertyGetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyGetStmtContext() *PropertyGetStmtContext {
	var p = new(PropertyGetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_propertyGetStmt
	return p
}

func (*PropertyGetStmtContext) IsPropertyGetStmtContext() {}

func NewPropertyGetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyGetStmtContext {
	var p = new(PropertyGetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_propertyGetStmt

	return p
}

func (s *PropertyGetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyGetStmtContext) PROPERTY_GET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPROPERTY_GET, 0)
}

func (s *PropertyGetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *PropertyGetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *PropertyGetStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *PropertyGetStmtContext) END_PROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_PROPERTY, 0)
}

func (s *PropertyGetStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *PropertyGetStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *PropertyGetStmtContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *PropertyGetStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *PropertyGetStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *PropertyGetStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *PropertyGetStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *PropertyGetStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *PropertyGetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyGetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertyGetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPropertyGetStmt(s)
	}
}

func (s *PropertyGetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPropertyGetStmt(s)
	}
}

func (p *VisualBasic6Parser) PropertyGetStmt() (localctx IPropertyGetStmtContext) {
	this := p
	_ = this

	localctx = NewPropertyGetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, VisualBasic6ParserRULE_propertyGetStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1607)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1604)
			p.Visibility()
		}
		{
			p.SetState(1605)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1611)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSTATIC {
		{
			p.SetState(1609)
			p.Match(VisualBasic6ParserSTATIC)
		}
		{
			p.SetState(1610)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1613)
		p.Match(VisualBasic6ParserPROPERTY_GET)
	}
	{
		p.SetState(1614)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1615)
		p.AmbiguousIdentifier()
	}
	p.SetState(1617)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(1616)
			p.TypeHint()
		}

	}
	p.SetState(1623)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 231, p.GetParserRuleContext()) == 1 {
		p.SetState(1620)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1619)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1622)
			p.ArgList()
		}

	}
	p.SetState(1627)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1625)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1626)
			p.AsTypeClause()
		}

	}
	p.SetState(1630)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1629)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1632)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1640)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1634)
			p.Block()
		}
		p.SetState(1636)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1635)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1638)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1642)
		p.Match(VisualBasic6ParserEND_PROPERTY)
	}

	return localctx
}

// IPropertySetStmtContext is an interface to support dynamic dispatch.
type IPropertySetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertySetStmtContext differentiates from other interfaces.
	IsPropertySetStmtContext()
}

type PropertySetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertySetStmtContext() *PropertySetStmtContext {
	var p = new(PropertySetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_propertySetStmt
	return p
}

func (*PropertySetStmtContext) IsPropertySetStmtContext() {}

func NewPropertySetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertySetStmtContext {
	var p = new(PropertySetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_propertySetStmt

	return p
}

func (s *PropertySetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertySetStmtContext) PROPERTY_SET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPROPERTY_SET, 0)
}

func (s *PropertySetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *PropertySetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *PropertySetStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *PropertySetStmtContext) END_PROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_PROPERTY, 0)
}

func (s *PropertySetStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *PropertySetStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *PropertySetStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *PropertySetStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *PropertySetStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *PropertySetStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *PropertySetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertySetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertySetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPropertySetStmt(s)
	}
}

func (s *PropertySetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPropertySetStmt(s)
	}
}

func (p *VisualBasic6Parser) PropertySetStmt() (localctx IPropertySetStmtContext) {
	this := p
	_ = this

	localctx = NewPropertySetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, VisualBasic6ParserRULE_propertySetStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1647)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1644)
			p.Visibility()
		}
		{
			p.SetState(1645)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1651)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSTATIC {
		{
			p.SetState(1649)
			p.Match(VisualBasic6ParserSTATIC)
		}
		{
			p.SetState(1650)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1653)
		p.Match(VisualBasic6ParserPROPERTY_SET)
	}
	{
		p.SetState(1654)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1655)
		p.AmbiguousIdentifier()
	}
	p.SetState(1660)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserLPAREN || _la == VisualBasic6ParserWS {
		p.SetState(1657)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1656)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1659)
			p.ArgList()
		}

	}
	p.SetState(1663)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1662)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1665)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1673)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1667)
			p.Block()
		}
		p.SetState(1669)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1668)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1671)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1675)
		p.Match(VisualBasic6ParserEND_PROPERTY)
	}

	return localctx
}

// IPropertyLetStmtContext is an interface to support dynamic dispatch.
type IPropertyLetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyLetStmtContext differentiates from other interfaces.
	IsPropertyLetStmtContext()
}

type PropertyLetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyLetStmtContext() *PropertyLetStmtContext {
	var p = new(PropertyLetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_propertyLetStmt
	return p
}

func (*PropertyLetStmtContext) IsPropertyLetStmtContext() {}

func NewPropertyLetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyLetStmtContext {
	var p = new(PropertyLetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_propertyLetStmt

	return p
}

func (s *PropertyLetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyLetStmtContext) PROPERTY_LET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPROPERTY_LET, 0)
}

func (s *PropertyLetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *PropertyLetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *PropertyLetStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *PropertyLetStmtContext) END_PROPERTY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_PROPERTY, 0)
}

func (s *PropertyLetStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *PropertyLetStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *PropertyLetStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *PropertyLetStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *PropertyLetStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *PropertyLetStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *PropertyLetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyLetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertyLetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPropertyLetStmt(s)
	}
}

func (s *PropertyLetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPropertyLetStmt(s)
	}
}

func (p *VisualBasic6Parser) PropertyLetStmt() (localctx IPropertyLetStmtContext) {
	this := p
	_ = this

	localctx = NewPropertyLetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, VisualBasic6ParserRULE_propertyLetStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1680)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1677)
			p.Visibility()
		}
		{
			p.SetState(1678)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1684)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSTATIC {
		{
			p.SetState(1682)
			p.Match(VisualBasic6ParserSTATIC)
		}
		{
			p.SetState(1683)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1686)
		p.Match(VisualBasic6ParserPROPERTY_LET)
	}
	{
		p.SetState(1687)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1688)
		p.AmbiguousIdentifier()
	}
	p.SetState(1693)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserLPAREN || _la == VisualBasic6ParserWS {
		p.SetState(1690)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1689)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1692)
			p.ArgList()
		}

	}
	p.SetState(1696)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1695)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1698)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1706)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(1700)
			p.Block()
		}
		p.SetState(1702)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1701)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1704)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1708)
		p.Match(VisualBasic6ParserEND_PROPERTY)
	}

	return localctx
}

// IPutStmtContext is an interface to support dynamic dispatch.
type IPutStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPutStmtContext differentiates from other interfaces.
	IsPutStmtContext()
}

type PutStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPutStmtContext() *PutStmtContext {
	var p = new(PutStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_putStmt
	return p
}

func (*PutStmtContext) IsPutStmtContext() {}

func NewPutStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PutStmtContext {
	var p = new(PutStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_putStmt

	return p
}

func (s *PutStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *PutStmtContext) PUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUT, 0)
}

func (s *PutStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *PutStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *PutStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *PutStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *PutStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *PutStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *PutStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PutStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PutStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPutStmt(s)
	}
}

func (s *PutStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPutStmt(s)
	}
}

func (p *VisualBasic6Parser) PutStmt() (localctx IPutStmtContext) {
	this := p
	_ = this

	localctx = NewPutStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, VisualBasic6ParserRULE_putStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1710)
		p.Match(VisualBasic6ParserPUT)
	}
	{
		p.SetState(1711)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1712)
		p.valueStmt(0)
	}
	p.SetState(1714)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1713)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1716)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1718)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 251, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1717)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1721)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 252, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1720)
			p.valueStmt(0)
		}

	}
	p.SetState(1724)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1723)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1726)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1728)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 254, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1727)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1730)
		p.valueStmt(0)
	}

	return localctx
}

// IRaiseEventStmtContext is an interface to support dynamic dispatch.
type IRaiseEventStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRaiseEventStmtContext differentiates from other interfaces.
	IsRaiseEventStmtContext()
}

type RaiseEventStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRaiseEventStmtContext() *RaiseEventStmtContext {
	var p = new(RaiseEventStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_raiseEventStmt
	return p
}

func (*RaiseEventStmtContext) IsRaiseEventStmtContext() {}

func NewRaiseEventStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RaiseEventStmtContext {
	var p = new(RaiseEventStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_raiseEventStmt

	return p
}

func (s *RaiseEventStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RaiseEventStmtContext) RAISEEVENT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRAISEEVENT, 0)
}

func (s *RaiseEventStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *RaiseEventStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *RaiseEventStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *RaiseEventStmtContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *RaiseEventStmtContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *RaiseEventStmtContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *RaiseEventStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RaiseEventStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RaiseEventStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRaiseEventStmt(s)
	}
}

func (s *RaiseEventStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRaiseEventStmt(s)
	}
}

func (p *VisualBasic6Parser) RaiseEventStmt() (localctx IRaiseEventStmtContext) {
	this := p
	_ = this

	localctx = NewRaiseEventStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, VisualBasic6ParserRULE_raiseEventStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1732)
		p.Match(VisualBasic6ParserRAISEEVENT)
	}
	{
		p.SetState(1733)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1734)
		p.AmbiguousIdentifier()
	}
	p.SetState(1749)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 259, p.GetParserRuleContext()) == 1 {
		p.SetState(1736)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1735)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1738)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(1740)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 256, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1739)
				p.Match(VisualBasic6ParserWS)
			}

		}
		p.SetState(1746)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserCOMMA-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164))|(1<<(VisualBasic6ParserLPAREN-164)))) != 0) || (((_la-196)&-(0x1f+1)) == 0 && ((1<<uint((_la-196)))&((1<<(VisualBasic6ParserMINUS-196))|(1<<(VisualBasic6ParserPLUS-196))|(1<<(VisualBasic6ParserSEMICOLON-196))|(1<<(VisualBasic6ParserL_SQUARE_BRACKET-196))|(1<<(VisualBasic6ParserSTRINGLITERAL-196))|(1<<(VisualBasic6ParserDATELITERAL-196))|(1<<(VisualBasic6ParserCOLORLITERAL-196))|(1<<(VisualBasic6ParserINTEGERLITERAL-196))|(1<<(VisualBasic6ParserDOUBLELITERAL-196))|(1<<(VisualBasic6ParserFILENUMBER-196))|(1<<(VisualBasic6ParserOCTALLITERAL-196))|(1<<(VisualBasic6ParserIDENTIFIER-196))|(1<<(VisualBasic6ParserWS-196)))) != 0) {
			{
				p.SetState(1742)
				p.ArgsCall()
			}
			p.SetState(1744)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1743)
					p.Match(VisualBasic6ParserWS)
				}

			}

		}
		{
			p.SetState(1748)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}

	return localctx
}

// IRandomizeStmtContext is an interface to support dynamic dispatch.
type IRandomizeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRandomizeStmtContext differentiates from other interfaces.
	IsRandomizeStmtContext()
}

type RandomizeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRandomizeStmtContext() *RandomizeStmtContext {
	var p = new(RandomizeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_randomizeStmt
	return p
}

func (*RandomizeStmtContext) IsRandomizeStmtContext() {}

func NewRandomizeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RandomizeStmtContext {
	var p = new(RandomizeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_randomizeStmt

	return p
}

func (s *RandomizeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RandomizeStmtContext) RANDOMIZE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRANDOMIZE, 0)
}

func (s *RandomizeStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *RandomizeStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *RandomizeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RandomizeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RandomizeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRandomizeStmt(s)
	}
}

func (s *RandomizeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRandomizeStmt(s)
	}
}

func (p *VisualBasic6Parser) RandomizeStmt() (localctx IRandomizeStmtContext) {
	this := p
	_ = this

	localctx = NewRandomizeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, VisualBasic6ParserRULE_randomizeStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1751)
		p.Match(VisualBasic6ParserRANDOMIZE)
	}
	p.SetState(1754)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 260, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1752)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1753)
			p.valueStmt(0)
		}

	}

	return localctx
}

// IRedimStmtContext is an interface to support dynamic dispatch.
type IRedimStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRedimStmtContext differentiates from other interfaces.
	IsRedimStmtContext()
}

type RedimStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRedimStmtContext() *RedimStmtContext {
	var p = new(RedimStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_redimStmt
	return p
}

func (*RedimStmtContext) IsRedimStmtContext() {}

func NewRedimStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RedimStmtContext {
	var p = new(RedimStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_redimStmt

	return p
}

func (s *RedimStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RedimStmtContext) REDIM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREDIM, 0)
}

func (s *RedimStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *RedimStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *RedimStmtContext) AllRedimSubStmt() []IRedimSubStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRedimSubStmtContext)(nil)).Elem())
	var tst = make([]IRedimSubStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IRedimSubStmtContext)
		}
	}

	return tst
}

func (s *RedimStmtContext) RedimSubStmt(i int) IRedimSubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRedimSubStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRedimSubStmtContext)
}

func (s *RedimStmtContext) PRESERVE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRESERVE, 0)
}

func (s *RedimStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *RedimStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *RedimStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RedimStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RedimStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRedimStmt(s)
	}
}

func (s *RedimStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRedimStmt(s)
	}
}

func (p *VisualBasic6Parser) RedimStmt() (localctx IRedimStmtContext) {
	this := p
	_ = this

	localctx = NewRedimStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, VisualBasic6ParserRULE_redimStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1756)
		p.Match(VisualBasic6ParserREDIM)
	}
	{
		p.SetState(1757)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(1760)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 261, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1758)
			p.Match(VisualBasic6ParserPRESERVE)
		}
		{
			p.SetState(1759)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1762)
		p.RedimSubStmt()
	}
	p.SetState(1773)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 264, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(1764)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(1763)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1766)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(1768)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 263, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1767)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(1770)
				p.RedimSubStmt()
			}

		}
		p.SetState(1775)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 264, p.GetParserRuleContext())
	}

	return localctx
}

// IRedimSubStmtContext is an interface to support dynamic dispatch.
type IRedimSubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRedimSubStmtContext differentiates from other interfaces.
	IsRedimSubStmtContext()
}

type RedimSubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRedimSubStmtContext() *RedimSubStmtContext {
	var p = new(RedimSubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_redimSubStmt
	return p
}

func (*RedimSubStmtContext) IsRedimSubStmtContext() {}

func NewRedimSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RedimSubStmtContext {
	var p = new(RedimSubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_redimSubStmt

	return p
}

func (s *RedimSubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RedimSubStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *RedimSubStmtContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *RedimSubStmtContext) Subscripts() ISubscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubscriptsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISubscriptsContext)
}

func (s *RedimSubStmtContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *RedimSubStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *RedimSubStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *RedimSubStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *RedimSubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RedimSubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RedimSubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRedimSubStmt(s)
	}
}

func (s *RedimSubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRedimSubStmt(s)
	}
}

func (p *VisualBasic6Parser) RedimSubStmt() (localctx IRedimSubStmtContext) {
	this := p
	_ = this

	localctx = NewRedimSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, VisualBasic6ParserRULE_redimSubStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1776)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(1778)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1777)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1780)
		p.Match(VisualBasic6ParserLPAREN)
	}
	p.SetState(1782)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 266, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1781)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1784)
		p.Subscripts()
	}
	p.SetState(1786)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1785)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1788)
		p.Match(VisualBasic6ParserRPAREN)
	}
	p.SetState(1791)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 268, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1789)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1790)
			p.AsTypeClause()
		}

	}

	return localctx
}

// IResetStmtContext is an interface to support dynamic dispatch.
type IResetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResetStmtContext differentiates from other interfaces.
	IsResetStmtContext()
}

type ResetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResetStmtContext() *ResetStmtContext {
	var p = new(ResetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_resetStmt
	return p
}

func (*ResetStmtContext) IsResetStmtContext() {}

func NewResetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetStmtContext {
	var p = new(ResetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_resetStmt

	return p
}

func (s *ResetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ResetStmtContext) RESET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRESET, 0)
}

func (s *ResetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterResetStmt(s)
	}
}

func (s *ResetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitResetStmt(s)
	}
}

func (p *VisualBasic6Parser) ResetStmt() (localctx IResetStmtContext) {
	this := p
	_ = this

	localctx = NewResetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, VisualBasic6ParserRULE_resetStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1793)
		p.Match(VisualBasic6ParserRESET)
	}

	return localctx
}

// IResumeStmtContext is an interface to support dynamic dispatch.
type IResumeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResumeStmtContext differentiates from other interfaces.
	IsResumeStmtContext()
}

type ResumeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResumeStmtContext() *ResumeStmtContext {
	var p = new(ResumeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_resumeStmt
	return p
}

func (*ResumeStmtContext) IsResumeStmtContext() {}

func NewResumeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResumeStmtContext {
	var p = new(ResumeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_resumeStmt

	return p
}

func (s *ResumeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ResumeStmtContext) RESUME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRESUME, 0)
}

func (s *ResumeStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ResumeStmtContext) NEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEXT, 0)
}

func (s *ResumeStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ResumeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResumeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResumeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterResumeStmt(s)
	}
}

func (s *ResumeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitResumeStmt(s)
	}
}

func (p *VisualBasic6Parser) ResumeStmt() (localctx IResumeStmtContext) {
	this := p
	_ = this

	localctx = NewResumeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, VisualBasic6ParserRULE_resumeStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1795)
		p.Match(VisualBasic6ParserRESUME)
	}
	p.SetState(1801)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 270, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1796)
			p.Match(VisualBasic6ParserWS)
		}
		p.SetState(1799)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 269, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1797)
				p.Match(VisualBasic6ParserNEXT)
			}

		case 2:
			{
				p.SetState(1798)
				p.AmbiguousIdentifier()
			}

		}

	}

	return localctx
}

// IReturnStmtContext is an interface to support dynamic dispatch.
type IReturnStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReturnStmtContext differentiates from other interfaces.
	IsReturnStmtContext()
}

type ReturnStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReturnStmtContext() *ReturnStmtContext {
	var p = new(ReturnStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_returnStmt
	return p
}

func (*ReturnStmtContext) IsReturnStmtContext() {}

func NewReturnStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStmtContext {
	var p = new(ReturnStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_returnStmt

	return p
}

func (s *ReturnStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ReturnStmtContext) RETURN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRETURN, 0)
}

func (s *ReturnStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReturnStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReturnStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterReturnStmt(s)
	}
}

func (s *ReturnStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitReturnStmt(s)
	}
}

func (p *VisualBasic6Parser) ReturnStmt() (localctx IReturnStmtContext) {
	this := p
	_ = this

	localctx = NewReturnStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, VisualBasic6ParserRULE_returnStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1803)
		p.Match(VisualBasic6ParserRETURN)
	}

	return localctx
}

// IRmdirStmtContext is an interface to support dynamic dispatch.
type IRmdirStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRmdirStmtContext differentiates from other interfaces.
	IsRmdirStmtContext()
}

type RmdirStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRmdirStmtContext() *RmdirStmtContext {
	var p = new(RmdirStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_rmdirStmt
	return p
}

func (*RmdirStmtContext) IsRmdirStmtContext() {}

func NewRmdirStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RmdirStmtContext {
	var p = new(RmdirStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_rmdirStmt

	return p
}

func (s *RmdirStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RmdirStmtContext) RMDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRMDIR, 0)
}

func (s *RmdirStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *RmdirStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *RmdirStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RmdirStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RmdirStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRmdirStmt(s)
	}
}

func (s *RmdirStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRmdirStmt(s)
	}
}

func (p *VisualBasic6Parser) RmdirStmt() (localctx IRmdirStmtContext) {
	this := p
	_ = this

	localctx = NewRmdirStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, VisualBasic6ParserRULE_rmdirStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1805)
		p.Match(VisualBasic6ParserRMDIR)
	}
	{
		p.SetState(1806)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1807)
		p.valueStmt(0)
	}

	return localctx
}

// IRsetStmtContext is an interface to support dynamic dispatch.
type IRsetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRsetStmtContext differentiates from other interfaces.
	IsRsetStmtContext()
}

type RsetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRsetStmtContext() *RsetStmtContext {
	var p = new(RsetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_rsetStmt
	return p
}

func (*RsetStmtContext) IsRsetStmtContext() {}

func NewRsetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RsetStmtContext {
	var p = new(RsetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_rsetStmt

	return p
}

func (s *RsetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *RsetStmtContext) RSET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRSET, 0)
}

func (s *RsetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *RsetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *RsetStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *RsetStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *RsetStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *RsetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RsetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RsetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterRsetStmt(s)
	}
}

func (s *RsetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitRsetStmt(s)
	}
}

func (p *VisualBasic6Parser) RsetStmt() (localctx IRsetStmtContext) {
	this := p
	_ = this

	localctx = NewRsetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, VisualBasic6ParserRULE_rsetStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1809)
		p.Match(VisualBasic6ParserRSET)
	}
	{
		p.SetState(1810)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1811)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(1813)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1812)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1815)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(1817)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 272, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1816)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1819)
		p.valueStmt(0)
	}

	return localctx
}

// ISavepictureStmtContext is an interface to support dynamic dispatch.
type ISavepictureStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSavepictureStmtContext differentiates from other interfaces.
	IsSavepictureStmtContext()
}

type SavepictureStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySavepictureStmtContext() *SavepictureStmtContext {
	var p = new(SavepictureStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_savepictureStmt
	return p
}

func (*SavepictureStmtContext) IsSavepictureStmtContext() {}

func NewSavepictureStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SavepictureStmtContext {
	var p = new(SavepictureStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_savepictureStmt

	return p
}

func (s *SavepictureStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SavepictureStmtContext) SAVEPICTURE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSAVEPICTURE, 0)
}

func (s *SavepictureStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SavepictureStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SavepictureStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *SavepictureStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SavepictureStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *SavepictureStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SavepictureStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SavepictureStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSavepictureStmt(s)
	}
}

func (s *SavepictureStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSavepictureStmt(s)
	}
}

func (p *VisualBasic6Parser) SavepictureStmt() (localctx ISavepictureStmtContext) {
	this := p
	_ = this

	localctx = NewSavepictureStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, VisualBasic6ParserRULE_savepictureStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1821)
		p.Match(VisualBasic6ParserSAVEPICTURE)
	}
	{
		p.SetState(1822)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1823)
		p.valueStmt(0)
	}
	p.SetState(1825)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1824)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1827)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1829)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 274, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1828)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1831)
		p.valueStmt(0)
	}

	return localctx
}

// ISaveSettingStmtContext is an interface to support dynamic dispatch.
type ISaveSettingStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSaveSettingStmtContext differentiates from other interfaces.
	IsSaveSettingStmtContext()
}

type SaveSettingStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySaveSettingStmtContext() *SaveSettingStmtContext {
	var p = new(SaveSettingStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_saveSettingStmt
	return p
}

func (*SaveSettingStmtContext) IsSaveSettingStmtContext() {}

func NewSaveSettingStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SaveSettingStmtContext {
	var p = new(SaveSettingStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_saveSettingStmt

	return p
}

func (s *SaveSettingStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SaveSettingStmtContext) SAVESETTING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSAVESETTING, 0)
}

func (s *SaveSettingStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SaveSettingStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SaveSettingStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *SaveSettingStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SaveSettingStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *SaveSettingStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *SaveSettingStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SaveSettingStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SaveSettingStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSaveSettingStmt(s)
	}
}

func (s *SaveSettingStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSaveSettingStmt(s)
	}
}

func (p *VisualBasic6Parser) SaveSettingStmt() (localctx ISaveSettingStmtContext) {
	this := p
	_ = this

	localctx = NewSaveSettingStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, VisualBasic6ParserRULE_saveSettingStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1833)
		p.Match(VisualBasic6ParserSAVESETTING)
	}
	{
		p.SetState(1834)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1835)
		p.valueStmt(0)
	}
	p.SetState(1837)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1836)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1839)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1841)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 276, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1840)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1843)
		p.valueStmt(0)
	}
	p.SetState(1845)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1844)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1847)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1849)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 278, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1848)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1851)
		p.valueStmt(0)
	}
	p.SetState(1853)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1852)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1855)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1857)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 280, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1856)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1859)
		p.valueStmt(0)
	}

	return localctx
}

// ISeekStmtContext is an interface to support dynamic dispatch.
type ISeekStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSeekStmtContext differentiates from other interfaces.
	IsSeekStmtContext()
}

type SeekStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySeekStmtContext() *SeekStmtContext {
	var p = new(SeekStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_seekStmt
	return p
}

func (*SeekStmtContext) IsSeekStmtContext() {}

func NewSeekStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeekStmtContext {
	var p = new(SeekStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_seekStmt

	return p
}

func (s *SeekStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SeekStmtContext) SEEK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSEEK, 0)
}

func (s *SeekStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SeekStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SeekStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *SeekStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SeekStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *SeekStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SeekStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SeekStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSeekStmt(s)
	}
}

func (s *SeekStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSeekStmt(s)
	}
}

func (p *VisualBasic6Parser) SeekStmt() (localctx ISeekStmtContext) {
	this := p
	_ = this

	localctx = NewSeekStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, VisualBasic6ParserRULE_seekStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1861)
		p.Match(VisualBasic6ParserSEEK)
	}
	{
		p.SetState(1862)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1863)
		p.valueStmt(0)
	}
	p.SetState(1865)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1864)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1867)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1869)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 282, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1868)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1871)
		p.valueStmt(0)
	}

	return localctx
}

// ISelectCaseStmtContext is an interface to support dynamic dispatch.
type ISelectCaseStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectCaseStmtContext differentiates from other interfaces.
	IsSelectCaseStmtContext()
}

type SelectCaseStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelectCaseStmtContext() *SelectCaseStmtContext {
	var p = new(SelectCaseStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_selectCaseStmt
	return p
}

func (*SelectCaseStmtContext) IsSelectCaseStmtContext() {}

func NewSelectCaseStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectCaseStmtContext {
	var p = new(SelectCaseStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_selectCaseStmt

	return p
}

func (s *SelectCaseStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectCaseStmtContext) SELECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSELECT, 0)
}

func (s *SelectCaseStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SelectCaseStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SelectCaseStmtContext) CASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCASE, 0)
}

func (s *SelectCaseStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SelectCaseStmtContext) END_SELECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_SELECT, 0)
}

func (s *SelectCaseStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *SelectCaseStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *SelectCaseStmtContext) AllSC_Case() []ISC_CaseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISC_CaseContext)(nil)).Elem())
	var tst = make([]ISC_CaseContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISC_CaseContext)
		}
	}

	return tst
}

func (s *SelectCaseStmtContext) SC_Case(i int) ISC_CaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISC_CaseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISC_CaseContext)
}

func (s *SelectCaseStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectCaseStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectCaseStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSelectCaseStmt(s)
	}
}

func (s *SelectCaseStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSelectCaseStmt(s)
	}
}

func (p *VisualBasic6Parser) SelectCaseStmt() (localctx ISelectCaseStmtContext) {
	this := p
	_ = this

	localctx = NewSelectCaseStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, VisualBasic6ParserRULE_selectCaseStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1873)
		p.Match(VisualBasic6ParserSELECT)
	}
	{
		p.SetState(1874)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1875)
		p.Match(VisualBasic6ParserCASE)
	}
	{
		p.SetState(1876)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1877)
		p.valueStmt(0)
	}
	p.SetState(1879)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(1878)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(1881)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1886)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == VisualBasic6ParserCASE {
		{
			p.SetState(1883)
			p.SC_Case()
		}

		p.SetState(1888)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1890)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1889)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1892)
		p.Match(VisualBasic6ParserEND_SELECT)
	}

	return localctx
}

// ISC_CaseContext is an interface to support dynamic dispatch.
type ISC_CaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSC_CaseContext differentiates from other interfaces.
	IsSC_CaseContext()
}

type SC_CaseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySC_CaseContext() *SC_CaseContext {
	var p = new(SC_CaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_sC_Case
	return p
}

func (*SC_CaseContext) IsSC_CaseContext() {}

func NewSC_CaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SC_CaseContext {
	var p = new(SC_CaseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_sC_Case

	return p
}

func (s *SC_CaseContext) GetParser() antlr.Parser { return s.parser }

func (s *SC_CaseContext) CASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCASE, 0)
}

func (s *SC_CaseContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SC_CaseContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SC_CaseContext) SC_Cond() ISC_CondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISC_CondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISC_CondContext)
}

func (s *SC_CaseContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *SC_CaseContext) COLON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLON, 0)
}

func (s *SC_CaseContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *SC_CaseContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *SC_CaseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SC_CaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SC_CaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSC_Case(s)
	}
}

func (s *SC_CaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSC_Case(s)
	}
}

func (p *VisualBasic6Parser) SC_Case() (localctx ISC_CaseContext) {
	this := p
	_ = this

	localctx = NewSC_CaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, VisualBasic6ParserRULE_sC_Case)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1894)
		p.Match(VisualBasic6ParserCASE)
	}
	{
		p.SetState(1895)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1896)
		p.SC_Cond()
	}
	p.SetState(1898)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 286, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1897)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(1914)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 290, p.GetParserRuleContext()) {
	case 1:
		p.SetState(1901)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserCOLON {
			{
				p.SetState(1900)
				p.Match(VisualBasic6ParserCOLON)
			}

		}
		p.SetState(1906)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1903)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1908)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	case 2:
		p.SetState(1910)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1909)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1912)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	p.SetState(1922)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 292, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1916)
			p.Block()
		}
		p.SetState(1918)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(1917)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(1920)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// ISC_CondContext is an interface to support dynamic dispatch.
type ISC_CondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSC_CondContext differentiates from other interfaces.
	IsSC_CondContext()
}

type SC_CondContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySC_CondContext() *SC_CondContext {
	var p = new(SC_CondContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_sC_Cond
	return p
}

func (*SC_CondContext) IsSC_CondContext() {}

func NewSC_CondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SC_CondContext {
	var p = new(SC_CondContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_sC_Cond

	return p
}

func (s *SC_CondContext) GetParser() antlr.Parser { return s.parser }

func (s *SC_CondContext) CopyFrom(ctx *SC_CondContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *SC_CondContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SC_CondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type CaseCondExprContext struct {
	*SC_CondContext
}

func NewCaseCondExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseCondExprContext {
	var p = new(CaseCondExprContext)

	p.SC_CondContext = NewEmptySC_CondContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SC_CondContext))

	return p
}

func (s *CaseCondExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseCondExprContext) AllSC_CondExpr() []ISC_CondExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISC_CondExprContext)(nil)).Elem())
	var tst = make([]ISC_CondExprContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISC_CondExprContext)
		}
	}

	return tst
}

func (s *CaseCondExprContext) SC_CondExpr(i int) ISC_CondExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISC_CondExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISC_CondExprContext)
}

func (s *CaseCondExprContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *CaseCondExprContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *CaseCondExprContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *CaseCondExprContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *CaseCondExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCaseCondExpr(s)
	}
}

func (s *CaseCondExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCaseCondExpr(s)
	}
}

type CaseCondElseContext struct {
	*SC_CondContext
}

func NewCaseCondElseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseCondElseContext {
	var p = new(CaseCondElseContext)

	p.SC_CondContext = NewEmptySC_CondContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SC_CondContext))

	return p
}

func (s *CaseCondElseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseCondElseContext) ELSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSE, 0)
}

func (s *CaseCondElseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCaseCondElse(s)
	}
}

func (s *CaseCondElseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCaseCondElse(s)
	}
}

func (p *VisualBasic6Parser) SC_Cond() (localctx ISC_CondContext) {
	this := p
	_ = this

	localctx = NewSC_CondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, VisualBasic6ParserRULE_sC_Cond)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.SetState(1939)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 296, p.GetParserRuleContext()) {
	case 1:
		localctx = NewCaseCondElseContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1924)
			p.Match(VisualBasic6ParserELSE)
		}

	case 2:
		localctx = NewCaseCondExprContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1925)
			p.SC_CondExpr()
		}
		p.SetState(1936)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 295, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(1927)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(1926)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(1929)
					p.Match(VisualBasic6ParserCOMMA)
				}
				p.SetState(1931)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 294, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1930)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(1933)
					p.SC_CondExpr()
				}

			}
			p.SetState(1938)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 295, p.GetParserRuleContext())
		}

	}

	return localctx
}

// ISC_CondExprContext is an interface to support dynamic dispatch.
type ISC_CondExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSC_CondExprContext differentiates from other interfaces.
	IsSC_CondExprContext()
}

type SC_CondExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySC_CondExprContext() *SC_CondExprContext {
	var p = new(SC_CondExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_sC_CondExpr
	return p
}

func (*SC_CondExprContext) IsSC_CondExprContext() {}

func NewSC_CondExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SC_CondExprContext {
	var p = new(SC_CondExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_sC_CondExpr

	return p
}

func (s *SC_CondExprContext) GetParser() antlr.Parser { return s.parser }

func (s *SC_CondExprContext) CopyFrom(ctx *SC_CondExprContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *SC_CondExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SC_CondExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type CaseCondExprValueContext struct {
	*SC_CondExprContext
}

func NewCaseCondExprValueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseCondExprValueContext {
	var p = new(CaseCondExprValueContext)

	p.SC_CondExprContext = NewEmptySC_CondExprContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SC_CondExprContext))

	return p
}

func (s *CaseCondExprValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseCondExprValueContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *CaseCondExprValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCaseCondExprValue(s)
	}
}

func (s *CaseCondExprValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCaseCondExprValue(s)
	}
}

type CaseCondExprIsContext struct {
	*SC_CondExprContext
}

func NewCaseCondExprIsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseCondExprIsContext {
	var p = new(CaseCondExprIsContext)

	p.SC_CondExprContext = NewEmptySC_CondExprContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SC_CondExprContext))

	return p
}

func (s *CaseCondExprIsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseCondExprIsContext) IS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIS, 0)
}

func (s *CaseCondExprIsContext) ComparisonOperator() IComparisonOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComparisonOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComparisonOperatorContext)
}

func (s *CaseCondExprIsContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *CaseCondExprIsContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *CaseCondExprIsContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *CaseCondExprIsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCaseCondExprIs(s)
	}
}

func (s *CaseCondExprIsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCaseCondExprIs(s)
	}
}

type CaseCondExprToContext struct {
	*SC_CondExprContext
}

func NewCaseCondExprToContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseCondExprToContext {
	var p = new(CaseCondExprToContext)

	p.SC_CondExprContext = NewEmptySC_CondExprContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SC_CondExprContext))

	return p
}

func (s *CaseCondExprToContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseCondExprToContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *CaseCondExprToContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *CaseCondExprToContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *CaseCondExprToContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *CaseCondExprToContext) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *CaseCondExprToContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCaseCondExprTo(s)
	}
}

func (s *CaseCondExprToContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCaseCondExprTo(s)
	}
}

func (p *VisualBasic6Parser) SC_CondExpr() (localctx ISC_CondExprContext) {
	this := p
	_ = this

	localctx = NewSC_CondExprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, VisualBasic6ParserRULE_sC_CondExpr)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1958)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 299, p.GetParserRuleContext()) {
	case 1:
		localctx = NewCaseCondExprIsContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1941)
			p.Match(VisualBasic6ParserIS)
		}
		p.SetState(1943)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1942)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1945)
			p.ComparisonOperator()
		}
		p.SetState(1947)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 298, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1946)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1949)
			p.valueStmt(0)
		}

	case 2:
		localctx = NewCaseCondExprValueContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1951)
			p.valueStmt(0)
		}

	case 3:
		localctx = NewCaseCondExprToContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1952)
			p.valueStmt(0)
		}
		{
			p.SetState(1953)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1954)
			p.Match(VisualBasic6ParserTO)
		}
		{
			p.SetState(1955)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(1956)
			p.valueStmt(0)
		}

	}

	return localctx
}

// ISendkeysStmtContext is an interface to support dynamic dispatch.
type ISendkeysStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSendkeysStmtContext differentiates from other interfaces.
	IsSendkeysStmtContext()
}

type SendkeysStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySendkeysStmtContext() *SendkeysStmtContext {
	var p = new(SendkeysStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_sendkeysStmt
	return p
}

func (*SendkeysStmtContext) IsSendkeysStmtContext() {}

func NewSendkeysStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SendkeysStmtContext {
	var p = new(SendkeysStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_sendkeysStmt

	return p
}

func (s *SendkeysStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SendkeysStmtContext) SENDKEYS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSENDKEYS, 0)
}

func (s *SendkeysStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SendkeysStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SendkeysStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *SendkeysStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SendkeysStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *SendkeysStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SendkeysStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SendkeysStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSendkeysStmt(s)
	}
}

func (s *SendkeysStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSendkeysStmt(s)
	}
}

func (p *VisualBasic6Parser) SendkeysStmt() (localctx ISendkeysStmtContext) {
	this := p
	_ = this

	localctx = NewSendkeysStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, VisualBasic6ParserRULE_sendkeysStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1960)
		p.Match(VisualBasic6ParserSENDKEYS)
	}
	{
		p.SetState(1961)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1962)
		p.valueStmt(0)
	}
	p.SetState(1971)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 302, p.GetParserRuleContext()) == 1 {
		p.SetState(1964)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(1963)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1966)
			p.Match(VisualBasic6ParserCOMMA)
		}
		p.SetState(1968)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 301, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1967)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(1970)
			p.valueStmt(0)
		}

	}

	return localctx
}

// ISetattrStmtContext is an interface to support dynamic dispatch.
type ISetattrStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSetattrStmtContext differentiates from other interfaces.
	IsSetattrStmtContext()
}

type SetattrStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySetattrStmtContext() *SetattrStmtContext {
	var p = new(SetattrStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_setattrStmt
	return p
}

func (*SetattrStmtContext) IsSetattrStmtContext() {}

func NewSetattrStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetattrStmtContext {
	var p = new(SetattrStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_setattrStmt

	return p
}

func (s *SetattrStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SetattrStmtContext) SETATTR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSETATTR, 0)
}

func (s *SetattrStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SetattrStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SetattrStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *SetattrStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SetattrStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *SetattrStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SetattrStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SetattrStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSetattrStmt(s)
	}
}

func (s *SetattrStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSetattrStmt(s)
	}
}

func (p *VisualBasic6Parser) SetattrStmt() (localctx ISetattrStmtContext) {
	this := p
	_ = this

	localctx = NewSetattrStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, VisualBasic6ParserRULE_setattrStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1973)
		p.Match(VisualBasic6ParserSETATTR)
	}
	{
		p.SetState(1974)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1975)
		p.valueStmt(0)
	}
	p.SetState(1977)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1976)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1979)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(1981)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 304, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1980)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1983)
		p.valueStmt(0)
	}

	return localctx
}

// ISetStmtContext is an interface to support dynamic dispatch.
type ISetStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSetStmtContext differentiates from other interfaces.
	IsSetStmtContext()
}

type SetStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySetStmtContext() *SetStmtContext {
	var p = new(SetStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_setStmt
	return p
}

func (*SetStmtContext) IsSetStmtContext() {}

func NewSetStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetStmtContext {
	var p = new(SetStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_setStmt

	return p
}

func (s *SetStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SetStmtContext) SET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSET, 0)
}

func (s *SetStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SetStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SetStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *SetStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *SetStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *SetStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SetStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SetStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSetStmt(s)
	}
}

func (s *SetStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSetStmt(s)
	}
}

func (p *VisualBasic6Parser) SetStmt() (localctx ISetStmtContext) {
	this := p
	_ = this

	localctx = NewSetStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, VisualBasic6ParserRULE_setStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1985)
		p.Match(VisualBasic6ParserSET)
	}
	{
		p.SetState(1986)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(1987)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(1989)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(1988)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1991)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(1993)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 306, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1992)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(1995)
		p.valueStmt(0)
	}

	return localctx
}

// IStopStmtContext is an interface to support dynamic dispatch.
type IStopStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStopStmtContext differentiates from other interfaces.
	IsStopStmtContext()
}

type StopStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStopStmtContext() *StopStmtContext {
	var p = new(StopStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_stopStmt
	return p
}

func (*StopStmtContext) IsStopStmtContext() {}

func NewStopStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StopStmtContext {
	var p = new(StopStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_stopStmt

	return p
}

func (s *StopStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *StopStmtContext) STOP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTOP, 0)
}

func (s *StopStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StopStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StopStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterStopStmt(s)
	}
}

func (s *StopStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitStopStmt(s)
	}
}

func (p *VisualBasic6Parser) StopStmt() (localctx IStopStmtContext) {
	this := p
	_ = this

	localctx = NewStopStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, VisualBasic6ParserRULE_stopStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1997)
		p.Match(VisualBasic6ParserSTOP)
	}

	return localctx
}

// ISubStmtContext is an interface to support dynamic dispatch.
type ISubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubStmtContext differentiates from other interfaces.
	IsSubStmtContext()
}

type SubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubStmtContext() *SubStmtContext {
	var p = new(SubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_subStmt
	return p
}

func (*SubStmtContext) IsSubStmtContext() {}

func NewSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubStmtContext {
	var p = new(SubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_subStmt

	return p
}

func (s *SubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *SubStmtContext) SUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSUB, 0)
}

func (s *SubStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SubStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SubStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *SubStmtContext) END_SUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_SUB, 0)
}

func (s *SubStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *SubStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *SubStmtContext) ArgList() IArgListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgListContext)
}

func (s *SubStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *SubStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *SubStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *SubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSubStmt(s)
	}
}

func (s *SubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSubStmt(s)
	}
}

func (p *VisualBasic6Parser) SubStmt() (localctx ISubStmtContext) {
	this := p
	_ = this

	localctx = NewSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, VisualBasic6ParserRULE_subStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2002)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(1999)
			p.Visibility()
		}
		{
			p.SetState(2000)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2006)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserSTATIC {
		{
			p.SetState(2004)
			p.Match(VisualBasic6ParserSTATIC)
		}
		{
			p.SetState(2005)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2008)
		p.Match(VisualBasic6ParserSUB)
	}
	{
		p.SetState(2009)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2010)
		p.AmbiguousIdentifier()
	}
	p.SetState(2015)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserLPAREN || _la == VisualBasic6ParserWS {
		p.SetState(2012)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2011)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2014)
			p.ArgList()
		}

	}
	p.SetState(2018)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(2017)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(2020)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(2028)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(2022)
			p.Block()
		}
		p.SetState(2024)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(2023)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(2026)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(2030)
		p.Match(VisualBasic6ParserEND_SUB)
	}

	return localctx
}

// ITimeStmtContext is an interface to support dynamic dispatch.
type ITimeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTimeStmtContext differentiates from other interfaces.
	IsTimeStmtContext()
}

type TimeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTimeStmtContext() *TimeStmtContext {
	var p = new(TimeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_timeStmt
	return p
}

func (*TimeStmtContext) IsTimeStmtContext() {}

func NewTimeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimeStmtContext {
	var p = new(TimeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_timeStmt

	return p
}

func (s *TimeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *TimeStmtContext) TIME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTIME, 0)
}

func (s *TimeStmtContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *TimeStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *TimeStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *TimeStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *TimeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TimeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TimeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterTimeStmt(s)
	}
}

func (s *TimeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitTimeStmt(s)
	}
}

func (p *VisualBasic6Parser) TimeStmt() (localctx ITimeStmtContext) {
	this := p
	_ = this

	localctx = NewTimeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, VisualBasic6ParserRULE_timeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2032)
		p.Match(VisualBasic6ParserTIME)
	}
	p.SetState(2034)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2033)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2036)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(2038)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 315, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2037)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2040)
		p.valueStmt(0)
	}

	return localctx
}

// ITypeStmtContext is an interface to support dynamic dispatch.
type ITypeStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeStmtContext differentiates from other interfaces.
	IsTypeStmtContext()
}

type TypeStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeStmtContext() *TypeStmtContext {
	var p = new(TypeStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_typeStmt
	return p
}

func (*TypeStmtContext) IsTypeStmtContext() {}

func NewTypeStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeStmtContext {
	var p = new(TypeStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_typeStmt

	return p
}

func (s *TypeStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeStmtContext) TYPE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTYPE, 0)
}

func (s *TypeStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *TypeStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *TypeStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *TypeStmtContext) END_TYPE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_TYPE, 0)
}

func (s *TypeStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *TypeStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *TypeStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *TypeStmtContext) AllTypeStmt_Element() []ITypeStmt_ElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeStmt_ElementContext)(nil)).Elem())
	var tst = make([]ITypeStmt_ElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeStmt_ElementContext)
		}
	}

	return tst
}

func (s *TypeStmtContext) TypeStmt_Element(i int) ITypeStmt_ElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeStmt_ElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeStmt_ElementContext)
}

func (s *TypeStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterTypeStmt(s)
	}
}

func (s *TypeStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitTypeStmt(s)
	}
}

func (p *VisualBasic6Parser) TypeStmt() (localctx ITypeStmtContext) {
	this := p
	_ = this

	localctx = NewTypeStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, VisualBasic6ParserRULE_typeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2045)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC {
		{
			p.SetState(2042)
			p.Visibility()
		}
		{
			p.SetState(2043)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2047)
		p.Match(VisualBasic6ParserTYPE)
	}
	{
		p.SetState(2048)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2049)
		p.AmbiguousIdentifier()
	}
	p.SetState(2051)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(2050)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(2053)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(2058)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164)))) != 0) || _la == VisualBasic6ParserL_SQUARE_BRACKET || _la == VisualBasic6ParserIDENTIFIER {
		{
			p.SetState(2055)
			p.TypeStmt_Element()
		}

		p.SetState(2060)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(2061)
		p.Match(VisualBasic6ParserEND_TYPE)
	}

	return localctx
}

// ITypeStmt_ElementContext is an interface to support dynamic dispatch.
type ITypeStmt_ElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeStmt_ElementContext differentiates from other interfaces.
	IsTypeStmt_ElementContext()
}

type TypeStmt_ElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeStmt_ElementContext() *TypeStmt_ElementContext {
	var p = new(TypeStmt_ElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_typeStmt_Element
	return p
}

func (*TypeStmt_ElementContext) IsTypeStmt_ElementContext() {}

func NewTypeStmt_ElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeStmt_ElementContext {
	var p = new(TypeStmt_ElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_typeStmt_Element

	return p
}

func (s *TypeStmt_ElementContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeStmt_ElementContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *TypeStmt_ElementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *TypeStmt_ElementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *TypeStmt_ElementContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *TypeStmt_ElementContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *TypeStmt_ElementContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *TypeStmt_ElementContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *TypeStmt_ElementContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *TypeStmt_ElementContext) Subscripts() ISubscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubscriptsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISubscriptsContext)
}

func (s *TypeStmt_ElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeStmt_ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeStmt_ElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterTypeStmt_Element(s)
	}
}

func (s *TypeStmt_ElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitTypeStmt_Element(s)
	}
}

func (p *VisualBasic6Parser) TypeStmt_Element() (localctx ITypeStmt_ElementContext) {
	this := p
	_ = this

	localctx = NewTypeStmt_ElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, VisualBasic6ParserRULE_typeStmt_Element)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2063)
		p.AmbiguousIdentifier()
	}
	p.SetState(2078)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 323, p.GetParserRuleContext()) == 1 {
		p.SetState(2065)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2064)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2067)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2072)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 321, p.GetParserRuleContext()) == 1 {
			p.SetState(2069)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 320, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2068)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2071)
				p.Subscripts()
			}

		}
		p.SetState(2075)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2074)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2077)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}
	p.SetState(2082)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2080)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2081)
			p.AsTypeClause()
		}

	}
	p.SetState(2085)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(2084)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(2087)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ITypeOfStmtContext is an interface to support dynamic dispatch.
type ITypeOfStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeOfStmtContext differentiates from other interfaces.
	IsTypeOfStmtContext()
}

type TypeOfStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeOfStmtContext() *TypeOfStmtContext {
	var p = new(TypeOfStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_typeOfStmt
	return p
}

func (*TypeOfStmtContext) IsTypeOfStmtContext() {}

func NewTypeOfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeOfStmtContext {
	var p = new(TypeOfStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_typeOfStmt

	return p
}

func (s *TypeOfStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeOfStmtContext) TYPEOF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTYPEOF, 0)
}

func (s *TypeOfStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *TypeOfStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *TypeOfStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *TypeOfStmtContext) IS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIS, 0)
}

func (s *TypeOfStmtContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *TypeOfStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeOfStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeOfStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterTypeOfStmt(s)
	}
}

func (s *TypeOfStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitTypeOfStmt(s)
	}
}

func (p *VisualBasic6Parser) TypeOfStmt() (localctx ITypeOfStmtContext) {
	this := p
	_ = this

	localctx = NewTypeOfStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, VisualBasic6ParserRULE_typeOfStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2089)
		p.Match(VisualBasic6ParserTYPEOF)
	}
	{
		p.SetState(2090)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2091)
		p.valueStmt(0)
	}
	p.SetState(2096)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 326, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2092)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2093)
			p.Match(VisualBasic6ParserIS)
		}
		{
			p.SetState(2094)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2095)
			p.Type_()
		}

	}

	return localctx
}

// IUnloadStmtContext is an interface to support dynamic dispatch.
type IUnloadStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnloadStmtContext differentiates from other interfaces.
	IsUnloadStmtContext()
}

type UnloadStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnloadStmtContext() *UnloadStmtContext {
	var p = new(UnloadStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_unloadStmt
	return p
}

func (*UnloadStmtContext) IsUnloadStmtContext() {}

func NewUnloadStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnloadStmtContext {
	var p = new(UnloadStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_unloadStmt

	return p
}

func (s *UnloadStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *UnloadStmtContext) UNLOAD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNLOAD, 0)
}

func (s *UnloadStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *UnloadStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *UnloadStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnloadStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnloadStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterUnloadStmt(s)
	}
}

func (s *UnloadStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitUnloadStmt(s)
	}
}

func (p *VisualBasic6Parser) UnloadStmt() (localctx IUnloadStmtContext) {
	this := p
	_ = this

	localctx = NewUnloadStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, VisualBasic6ParserRULE_unloadStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2098)
		p.Match(VisualBasic6ParserUNLOAD)
	}
	{
		p.SetState(2099)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2100)
		p.valueStmt(0)
	}

	return localctx
}

// IUnlockStmtContext is an interface to support dynamic dispatch.
type IUnlockStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnlockStmtContext differentiates from other interfaces.
	IsUnlockStmtContext()
}

type UnlockStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnlockStmtContext() *UnlockStmtContext {
	var p = new(UnlockStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_unlockStmt
	return p
}

func (*UnlockStmtContext) IsUnlockStmtContext() {}

func NewUnlockStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlockStmtContext {
	var p = new(UnlockStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_unlockStmt

	return p
}

func (s *UnlockStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *UnlockStmtContext) UNLOCK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNLOCK, 0)
}

func (s *UnlockStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *UnlockStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *UnlockStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *UnlockStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *UnlockStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *UnlockStmtContext) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *UnlockStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnlockStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnlockStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterUnlockStmt(s)
	}
}

func (s *UnlockStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitUnlockStmt(s)
	}
}

func (p *VisualBasic6Parser) UnlockStmt() (localctx IUnlockStmtContext) {
	this := p
	_ = this

	localctx = NewUnlockStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, VisualBasic6ParserRULE_unlockStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2102)
		p.Match(VisualBasic6ParserUNLOCK)
	}
	{
		p.SetState(2103)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2104)
		p.valueStmt(0)
	}
	p.SetState(2119)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 330, p.GetParserRuleContext()) == 1 {
		p.SetState(2106)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2105)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2108)
			p.Match(VisualBasic6ParserCOMMA)
		}
		p.SetState(2110)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 328, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2109)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2112)
			p.valueStmt(0)
		}
		p.SetState(2117)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 329, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2113)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(2114)
				p.Match(VisualBasic6ParserTO)
			}
			{
				p.SetState(2115)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(2116)
				p.valueStmt(0)
			}

		}

	}

	return localctx
}

// IValueStmtContext is an interface to support dynamic dispatch.
type IValueStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsValueStmtContext differentiates from other interfaces.
	IsValueStmtContext()
}

type ValueStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyValueStmtContext() *ValueStmtContext {
	var p = new(ValueStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_valueStmt
	return p
}

func (*ValueStmtContext) IsValueStmtContext() {}

func NewValueStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueStmtContext {
	var p = new(ValueStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_valueStmt

	return p
}

func (s *ValueStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ValueStmtContext) CopyFrom(ctx *ValueStmtContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *ValueStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ValueStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type VsAssignContext struct {
	*ValueStmtContext
}

func NewVsAssignContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsAssignContext {
	var p = new(VsAssignContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsAssignContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsAssignContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *VsAssignContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserASSIGN, 0)
}

func (s *VsAssignContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsAssignContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsAssignContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsAssignContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsAssign(s)
	}
}

func (s *VsAssignContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsAssign(s)
	}
}

type VsNotContext struct {
	*ValueStmtContext
}

func NewVsNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsNotContext {
	var p = new(VsNotContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsNotContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsNotContext) NOT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNOT, 0)
}

func (s *VsNotContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsNotContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsNotContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsNotContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *VsNotContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *VsNotContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsNot(s)
	}
}

func (s *VsNotContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsNot(s)
	}
}

type VsStructContext struct {
	*ValueStmtContext
}

func NewVsStructContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsStructContext {
	var p = new(VsStructContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsStructContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsStructContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *VsStructContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsStructContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsStructContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *VsStructContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsStructContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsStructContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *VsStructContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *VsStructContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsStruct(s)
	}
}

func (s *VsStructContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsStruct(s)
	}
}

type VsMultDivContext struct {
	*ValueStmtContext
}

func NewVsMultDivContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsMultDivContext {
	var p = new(VsMultDivContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsMultDivContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsMultDivContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsMultDivContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsMultDivContext) MULT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMULT, 0)
}

func (s *VsMultDivContext) DIV() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDIV, 0)
}

func (s *VsMultDivContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsMultDivContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsMultDivContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsMultDiv(s)
	}
}

func (s *VsMultDivContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsMultDiv(s)
	}
}

type VsTypeOfContext struct {
	*ValueStmtContext
}

func NewVsTypeOfContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsTypeOfContext {
	var p = new(VsTypeOfContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsTypeOfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsTypeOfContext) TypeOfStmt() ITypeOfStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeOfStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeOfStmtContext)
}

func (s *VsTypeOfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsTypeOf(s)
	}
}

func (s *VsTypeOfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsTypeOf(s)
	}
}

type VsICSContext struct {
	*ValueStmtContext
}

func NewVsICSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsICSContext {
	var p = new(VsICSContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsICSContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsICSContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *VsICSContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsICS(s)
	}
}

func (s *VsICSContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsICS(s)
	}
}

type VsXorContext struct {
	*ValueStmtContext
}

func NewVsXorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsXorContext {
	var p = new(VsXorContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsXorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsXorContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsXorContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsXorContext) XOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserXOR, 0)
}

func (s *VsXorContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsXorContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsXorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsXor(s)
	}
}

func (s *VsXorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsXor(s)
	}
}

type VsAddSubContext struct {
	*ValueStmtContext
}

func NewVsAddSubContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsAddSubContext {
	var p = new(VsAddSubContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsAddSubContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsAddSubContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsAddSubContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsAddSubContext) PLUS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPLUS, 0)
}

func (s *VsAddSubContext) MINUS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMINUS, 0)
}

func (s *VsAddSubContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsAddSubContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsAddSubContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsAddSub(s)
	}
}

func (s *VsAddSubContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsAddSub(s)
	}
}

type VsAndContext struct {
	*ValueStmtContext
}

func NewVsAndContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsAndContext {
	var p = new(VsAndContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsAndContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsAndContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsAndContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsAndContext) AND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAND, 0)
}

func (s *VsAndContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsAndContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsAndContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsAnd(s)
	}
}

func (s *VsAndContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsAnd(s)
	}
}

type VsPowContext struct {
	*ValueStmtContext
}

func NewVsPowContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsPowContext {
	var p = new(VsPowContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsPowContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsPowContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsPowContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsPowContext) POW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPOW, 0)
}

func (s *VsPowContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsPowContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsPowContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsPow(s)
	}
}

func (s *VsPowContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsPow(s)
	}
}

type VsModContext struct {
	*ValueStmtContext
}

func NewVsModContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsModContext {
	var p = new(VsModContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsModContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsModContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsModContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsModContext) MOD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMOD, 0)
}

func (s *VsModContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsModContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsModContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsMod(s)
	}
}

func (s *VsModContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsMod(s)
	}
}

type VsAmpContext struct {
	*ValueStmtContext
}

func NewVsAmpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsAmpContext {
	var p = new(VsAmpContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsAmpContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsAmpContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsAmpContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsAmpContext) AMPERSAND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAMPERSAND, 0)
}

func (s *VsAmpContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsAmpContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsAmpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsAmp(s)
	}
}

func (s *VsAmpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsAmp(s)
	}
}

type VsAddressOfContext struct {
	*ValueStmtContext
}

func NewVsAddressOfContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsAddressOfContext {
	var p = new(VsAddressOfContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsAddressOfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsAddressOfContext) ADDRESSOF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserADDRESSOF, 0)
}

func (s *VsAddressOfContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *VsAddressOfContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsAddressOfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsAddressOf(s)
	}
}

func (s *VsAddressOfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsAddressOf(s)
	}
}

type VsNewContext struct {
	*ValueStmtContext
}

func NewVsNewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsNewContext {
	var p = new(VsNewContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsNewContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsNewContext) NEW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEW, 0)
}

func (s *VsNewContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *VsNewContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsNewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsNew(s)
	}
}

func (s *VsNewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsNew(s)
	}
}

type VsPlusMinusContext struct {
	*ValueStmtContext
}

func NewVsPlusMinusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsPlusMinusContext {
	var p = new(VsPlusMinusContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsPlusMinusContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsPlusMinusContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsPlusMinusContext) PLUS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPLUS, 0)
}

func (s *VsPlusMinusContext) MINUS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMINUS, 0)
}

func (s *VsPlusMinusContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *VsPlusMinusContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsPlusMinus(s)
	}
}

func (s *VsPlusMinusContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsPlusMinus(s)
	}
}

type VsIDivContext struct {
	*ValueStmtContext
}

func NewVsIDivContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsIDivContext {
	var p = new(VsIDivContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsIDivContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsIDivContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsIDivContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsIDivContext) IDIV() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIDIV, 0)
}

func (s *VsIDivContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsIDivContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsIDivContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsIDiv(s)
	}
}

func (s *VsIDivContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsIDiv(s)
	}
}

type VsOrContext struct {
	*ValueStmtContext
}

func NewVsOrContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsOrContext {
	var p = new(VsOrContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsOrContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsOrContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsOrContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsOrContext) OR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOR, 0)
}

func (s *VsOrContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsOrContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsOrContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsOr(s)
	}
}

func (s *VsOrContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsOr(s)
	}
}

type VsLiteralContext struct {
	*ValueStmtContext
}

func NewVsLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsLiteralContext {
	var p = new(VsLiteralContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsLiteralContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *VsLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsLiteral(s)
	}
}

func (s *VsLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsLiteral(s)
	}
}

type VsEqvContext struct {
	*ValueStmtContext
}

func NewVsEqvContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsEqvContext {
	var p = new(VsEqvContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsEqvContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsEqvContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsEqvContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsEqvContext) EQV() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQV, 0)
}

func (s *VsEqvContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsEqvContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsEqvContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsEqv(s)
	}
}

func (s *VsEqvContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsEqv(s)
	}
}

type VsImpContext struct {
	*ValueStmtContext
}

func NewVsImpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsImpContext {
	var p = new(VsImpContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsImpContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsImpContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsImpContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsImpContext) IMP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIMP, 0)
}

func (s *VsImpContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsImpContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsImpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsImp(s)
	}
}

func (s *VsImpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsImp(s)
	}
}

type VsCompContext struct {
	*ValueStmtContext
}

func NewVsCompContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsCompContext {
	var p = new(VsCompContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsCompContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsCompContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *VsCompContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *VsCompContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *VsCompContext) NEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEQ, 0)
}

func (s *VsCompContext) LT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLT, 0)
}

func (s *VsCompContext) GT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGT, 0)
}

func (s *VsCompContext) LEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLEQ, 0)
}

func (s *VsCompContext) GEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGEQ, 0)
}

func (s *VsCompContext) LIKE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLIKE, 0)
}

func (s *VsCompContext) IS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIS, 0)
}

func (s *VsCompContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VsCompContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VsCompContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsComp(s)
	}
}

func (s *VsCompContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsComp(s)
	}
}

type VsMidContext struct {
	*ValueStmtContext
}

func NewVsMidContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VsMidContext {
	var p = new(VsMidContext)

	p.ValueStmtContext = NewEmptyValueStmtContext()
	p.parser = parser
	p.CopyFrom(ctx.(*ValueStmtContext))

	return p
}

func (s *VsMidContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VsMidContext) MidStmt() IMidStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMidStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMidStmtContext)
}

func (s *VsMidContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVsMid(s)
	}
}

func (s *VsMidContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVsMid(s)
	}
}

func (p *VisualBasic6Parser) ValueStmt() (localctx IValueStmtContext) {
	return p.valueStmt(0)
}

func (p *VisualBasic6Parser) valueStmt(_p int) (localctx IValueStmtContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewValueStmtContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IValueStmtContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 220
	p.EnterRecursionRule(localctx, 220, VisualBasic6ParserRULE_valueStmt, _p)
	var _la int

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2185)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 342, p.GetParserRuleContext()) {
	case 1:
		localctx = NewVsLiteralContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx

		{
			p.SetState(2122)
			p.Literal()
		}

	case 2:
		localctx = NewVsStructContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2123)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2125)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 331, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2124)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2127)
			p.valueStmt(0)
		}
		p.SetState(2138)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 334, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(2129)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2128)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2131)
					p.Match(VisualBasic6ParserCOMMA)
				}
				p.SetState(2133)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 333, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2132)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2135)
					p.valueStmt(0)
				}

			}
			p.SetState(2140)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 334, p.GetParserRuleContext())
		}
		p.SetState(2142)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2141)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2144)
			p.Match(VisualBasic6ParserRPAREN)
		}

	case 3:
		localctx = NewVsNewContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2146)
			p.Match(VisualBasic6ParserNEW)
		}
		{
			p.SetState(2147)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2148)
			p.valueStmt(20)
		}

	case 4:
		localctx = NewVsTypeOfContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2149)
			p.TypeOfStmt()
		}

	case 5:
		localctx = NewVsAddressOfContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2150)
			p.Match(VisualBasic6ParserADDRESSOF)
		}
		{
			p.SetState(2151)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2152)
			p.valueStmt(18)
		}

	case 6:
		localctx = NewVsAssignContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2153)
			p.ImplicitCallStmt_InStmt()
		}
		p.SetState(2155)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2154)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2157)
			p.Match(VisualBasic6ParserASSIGN)
		}
		p.SetState(2159)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 337, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2158)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2161)
			p.valueStmt(17)
		}

	case 7:
		localctx = NewVsPlusMinusContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2163)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserMINUS || _la == VisualBasic6ParserPLUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(2165)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 338, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2164)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2167)
			p.valueStmt(15)
		}

	case 8:
		localctx = NewVsNotContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2168)
			p.Match(VisualBasic6ParserNOT)
		}
		p.SetState(2181)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case VisualBasic6ParserWS:
			{
				p.SetState(2169)
				p.Match(VisualBasic6ParserWS)
			}
			{
				p.SetState(2170)
				p.valueStmt(0)
			}

		case VisualBasic6ParserLPAREN:
			{
				p.SetState(2171)
				p.Match(VisualBasic6ParserLPAREN)
			}
			p.SetState(2173)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 339, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2172)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2175)
				p.valueStmt(0)
			}
			p.SetState(2177)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2176)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2179)
				p.Match(VisualBasic6ParserRPAREN)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

	case 9:
		localctx = NewVsICSContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2183)
			p.ImplicitCallStmt_InStmt()
		}

	case 10:
		localctx = NewVsMidContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(2184)
			p.MidStmt()
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2297)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 368, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2295)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 367, p.GetParserRuleContext()) {
			case 1:
				localctx = NewVsPowContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2187)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				p.SetState(2189)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2188)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2191)
					p.Match(VisualBasic6ParserPOW)
				}
				p.SetState(2193)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 344, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2192)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2195)
					p.valueStmt(17)
				}

			case 2:
				localctx = NewVsMultDivContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2196)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				p.SetState(2198)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2197)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2200)
					_la = p.GetTokenStream().LA(1)

					if !(_la == VisualBasic6ParserDIV || _la == VisualBasic6ParserMULT) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(2202)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 346, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2201)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2204)
					p.valueStmt(15)
				}

			case 3:
				localctx = NewVsIDivContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2205)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				p.SetState(2207)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2206)
						p.Match(VisualBasic6ParserWS)
					}

				}

				{
					p.SetState(2209)
					p.Match(VisualBasic6ParserIDIV)
				}

				p.SetState(2211)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 348, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2210)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2213)
					p.valueStmt(14)
				}

			case 4:
				localctx = NewVsModContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2214)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				p.SetState(2216)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2215)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2218)
					p.Match(VisualBasic6ParserMOD)
				}
				p.SetState(2220)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 350, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2219)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2222)
					p.valueStmt(13)
				}

			case 5:
				localctx = NewVsAddSubContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2223)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				p.SetState(2225)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2224)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2227)
					_la = p.GetTokenStream().LA(1)

					if !(_la == VisualBasic6ParserMINUS || _la == VisualBasic6ParserPLUS) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(2229)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 352, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2228)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2231)
					p.valueStmt(12)
				}

			case 6:
				localctx = NewVsAmpContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2232)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				p.SetState(2234)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2233)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2236)
					p.Match(VisualBasic6ParserAMPERSAND)
				}
				p.SetState(2238)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 354, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2237)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2240)
					p.valueStmt(11)
				}

			case 7:
				localctx = NewVsCompContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2241)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				p.SetState(2243)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2242)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2245)
					_la = p.GetTokenStream().LA(1)

					if !(_la == VisualBasic6ParserIS || _la == VisualBasic6ParserLIKE || (((_la-187)&-(0x1f+1)) == 0 && ((1<<uint((_la-187)))&((1<<(VisualBasic6ParserEQ-187))|(1<<(VisualBasic6ParserGEQ-187))|(1<<(VisualBasic6ParserGT-187))|(1<<(VisualBasic6ParserLEQ-187))|(1<<(VisualBasic6ParserLT-187))|(1<<(VisualBasic6ParserNEQ-187)))) != 0)) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(2247)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 356, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2246)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2249)
					p.valueStmt(10)
				}

			case 8:
				localctx = NewVsAndContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2250)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				p.SetState(2252)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2251)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2254)
					p.Match(VisualBasic6ParserAND)
				}
				p.SetState(2256)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 358, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2255)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2258)
					p.valueStmt(8)
				}

			case 9:
				localctx = NewVsOrContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2259)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				p.SetState(2261)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2260)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2263)
					p.Match(VisualBasic6ParserOR)
				}
				p.SetState(2265)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 360, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2264)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2267)
					p.valueStmt(7)
				}

			case 10:
				localctx = NewVsXorContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2268)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				p.SetState(2270)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2269)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2272)
					p.Match(VisualBasic6ParserXOR)
				}
				p.SetState(2274)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 362, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2273)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2276)
					p.valueStmt(6)
				}

			case 11:
				localctx = NewVsEqvContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2277)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				p.SetState(2279)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2278)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2281)
					p.Match(VisualBasic6ParserEQV)
				}
				p.SetState(2283)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 364, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2282)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2285)
					p.valueStmt(5)
				}

			case 12:
				localctx = NewVsImpContext(p, NewValueStmtContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, VisualBasic6ParserRULE_valueStmt)
				p.SetState(2286)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				p.SetState(2288)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2287)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2290)
					p.Match(VisualBasic6ParserIMP)
				}
				p.SetState(2292)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 366, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(2291)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2294)
					p.valueStmt(4)
				}

			}

		}
		p.SetState(2299)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 368, p.GetParserRuleContext())
	}

	return localctx
}

// IVariableStmtContext is an interface to support dynamic dispatch.
type IVariableStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableStmtContext differentiates from other interfaces.
	IsVariableStmtContext()
}

type VariableStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableStmtContext() *VariableStmtContext {
	var p = new(VariableStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_variableStmt
	return p
}

func (*VariableStmtContext) IsVariableStmtContext() {}

func NewVariableStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableStmtContext {
	var p = new(VariableStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_variableStmt

	return p
}

func (s *VariableStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VariableStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VariableStmtContext) VariableListStmt() IVariableListStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableListStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableListStmtContext)
}

func (s *VariableStmtContext) DIM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDIM, 0)
}

func (s *VariableStmtContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *VariableStmtContext) Visibility() IVisibilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVisibilityContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVisibilityContext)
}

func (s *VariableStmtContext) WITHEVENTS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWITHEVENTS, 0)
}

func (s *VariableStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVariableStmt(s)
	}
}

func (s *VariableStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVariableStmt(s)
	}
}

func (p *VisualBasic6Parser) VariableStmt() (localctx IVariableStmtContext) {
	this := p
	_ = this

	localctx = NewVariableStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, VisualBasic6ParserRULE_variableStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2303)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserDIM:
		{
			p.SetState(2300)
			p.Match(VisualBasic6ParserDIM)
		}

	case VisualBasic6ParserSTATIC:
		{
			p.SetState(2301)
			p.Match(VisualBasic6ParserSTATIC)
		}

	case VisualBasic6ParserFRIEND, VisualBasic6ParserGLOBAL, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC:
		{
			p.SetState(2302)
			p.Visibility()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(2305)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(2308)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 370, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2306)
			p.Match(VisualBasic6ParserWITHEVENTS)
		}
		{
			p.SetState(2307)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2310)
		p.VariableListStmt()
	}

	return localctx
}

// IVariableListStmtContext is an interface to support dynamic dispatch.
type IVariableListStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableListStmtContext differentiates from other interfaces.
	IsVariableListStmtContext()
}

type VariableListStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableListStmtContext() *VariableListStmtContext {
	var p = new(VariableListStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_variableListStmt
	return p
}

func (*VariableListStmtContext) IsVariableListStmtContext() {}

func NewVariableListStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableListStmtContext {
	var p = new(VariableListStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_variableListStmt

	return p
}

func (s *VariableListStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableListStmtContext) AllVariableSubStmt() []IVariableSubStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableSubStmtContext)(nil)).Elem())
	var tst = make([]IVariableSubStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableSubStmtContext)
		}
	}

	return tst
}

func (s *VariableListStmtContext) VariableSubStmt(i int) IVariableSubStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableSubStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableSubStmtContext)
}

func (s *VariableListStmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *VariableListStmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *VariableListStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VariableListStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VariableListStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableListStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableListStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVariableListStmt(s)
	}
}

func (s *VariableListStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVariableListStmt(s)
	}
}

func (p *VisualBasic6Parser) VariableListStmt() (localctx IVariableListStmtContext) {
	this := p
	_ = this

	localctx = NewVariableListStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, VisualBasic6ParserRULE_variableListStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2312)
		p.VariableSubStmt()
	}
	p.SetState(2323)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 373, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(2314)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2313)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2316)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(2318)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2317)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2320)
				p.VariableSubStmt()
			}

		}
		p.SetState(2325)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 373, p.GetParserRuleContext())
	}

	return localctx
}

// IVariableSubStmtContext is an interface to support dynamic dispatch.
type IVariableSubStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableSubStmtContext differentiates from other interfaces.
	IsVariableSubStmtContext()
}

type VariableSubStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableSubStmtContext() *VariableSubStmtContext {
	var p = new(VariableSubStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_variableSubStmt
	return p
}

func (*VariableSubStmtContext) IsVariableSubStmtContext() {}

func NewVariableSubStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableSubStmtContext {
	var p = new(VariableSubStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_variableSubStmt

	return p
}

func (s *VariableSubStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableSubStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *VariableSubStmtContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *VariableSubStmtContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *VariableSubStmtContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *VariableSubStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *VariableSubStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *VariableSubStmtContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *VariableSubStmtContext) Subscripts() ISubscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubscriptsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISubscriptsContext)
}

func (s *VariableSubStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableSubStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableSubStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVariableSubStmt(s)
	}
}

func (s *VariableSubStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVariableSubStmt(s)
	}
}

func (p *VisualBasic6Parser) VariableSubStmt() (localctx IVariableSubStmtContext) {
	this := p
	_ = this

	localctx = NewVariableSubStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, VisualBasic6ParserRULE_variableSubStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2326)
		p.AmbiguousIdentifier()
	}
	p.SetState(2328)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 374, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2327)
			p.TypeHint()
		}

	}
	p.SetState(2347)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 380, p.GetParserRuleContext()) == 1 {
		p.SetState(2331)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2330)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2333)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2335)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 376, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2334)
				p.Match(VisualBasic6ParserWS)
			}

		}
		p.SetState(2341)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164))|(1<<(VisualBasic6ParserLPAREN-164)))) != 0) || (((_la-196)&-(0x1f+1)) == 0 && ((1<<uint((_la-196)))&((1<<(VisualBasic6ParserMINUS-196))|(1<<(VisualBasic6ParserPLUS-196))|(1<<(VisualBasic6ParserL_SQUARE_BRACKET-196))|(1<<(VisualBasic6ParserSTRINGLITERAL-196))|(1<<(VisualBasic6ParserDATELITERAL-196))|(1<<(VisualBasic6ParserCOLORLITERAL-196))|(1<<(VisualBasic6ParserINTEGERLITERAL-196))|(1<<(VisualBasic6ParserDOUBLELITERAL-196))|(1<<(VisualBasic6ParserFILENUMBER-196))|(1<<(VisualBasic6ParserOCTALLITERAL-196))|(1<<(VisualBasic6ParserIDENTIFIER-196))|(1<<(VisualBasic6ParserWS-196)))) != 0) {
			{
				p.SetState(2337)
				p.Subscripts()
			}
			p.SetState(2339)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2338)
					p.Match(VisualBasic6ParserWS)
				}

			}

		}
		{
			p.SetState(2343)
			p.Match(VisualBasic6ParserRPAREN)
		}
		p.SetState(2345)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 379, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2344)
				p.Match(VisualBasic6ParserWS)
			}

		}

	}
	p.SetState(2351)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 381, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2349)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2350)
			p.AsTypeClause()
		}

	}

	return localctx
}

// IWhileWendStmtContext is an interface to support dynamic dispatch.
type IWhileWendStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhileWendStmtContext differentiates from other interfaces.
	IsWhileWendStmtContext()
}

type WhileWendStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhileWendStmtContext() *WhileWendStmtContext {
	var p = new(WhileWendStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_whileWendStmt
	return p
}

func (*WhileWendStmtContext) IsWhileWendStmtContext() {}

func NewWhileWendStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileWendStmtContext {
	var p = new(WhileWendStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_whileWendStmt

	return p
}

func (s *WhileWendStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *WhileWendStmtContext) WHILE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWHILE, 0)
}

func (s *WhileWendStmtContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *WhileWendStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *WhileWendStmtContext) WEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWEND, 0)
}

func (s *WhileWendStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *WhileWendStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *WhileWendStmtContext) AllBlock() []IBlockContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBlockContext)(nil)).Elem())
	var tst = make([]IBlockContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IBlockContext)
		}
	}

	return tst
}

func (s *WhileWendStmtContext) Block(i int) IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *WhileWendStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WhileWendStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WhileWendStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterWhileWendStmt(s)
	}
}

func (s *WhileWendStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitWhileWendStmt(s)
	}
}

func (p *VisualBasic6Parser) WhileWendStmt() (localctx IWhileWendStmtContext) {
	this := p
	_ = this

	localctx = NewWhileWendStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, VisualBasic6ParserRULE_whileWendStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2353)
		p.Match(VisualBasic6ParserWHILE)
	}
	{
		p.SetState(2354)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2355)
		p.valueStmt(0)
	}
	p.SetState(2357)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(2356)
				p.Match(VisualBasic6ParserNEWLINE)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(2359)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 382, p.GetParserRuleContext())
	}
	p.SetState(2364)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 383, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(2361)
				p.Block()
			}

		}
		p.SetState(2366)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 383, p.GetParserRuleContext())
	}
	p.SetState(2370)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(2367)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(2372)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(2373)
		p.Match(VisualBasic6ParserWEND)
	}

	return localctx
}

// IWidthStmtContext is an interface to support dynamic dispatch.
type IWidthStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWidthStmtContext differentiates from other interfaces.
	IsWidthStmtContext()
}

type WidthStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWidthStmtContext() *WidthStmtContext {
	var p = new(WidthStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_widthStmt
	return p
}

func (*WidthStmtContext) IsWidthStmtContext() {}

func NewWidthStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WidthStmtContext {
	var p = new(WidthStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_widthStmt

	return p
}

func (s *WidthStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *WidthStmtContext) WIDTH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWIDTH, 0)
}

func (s *WidthStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *WidthStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *WidthStmtContext) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *WidthStmtContext) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *WidthStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *WidthStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WidthStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WidthStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterWidthStmt(s)
	}
}

func (s *WidthStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitWidthStmt(s)
	}
}

func (p *VisualBasic6Parser) WidthStmt() (localctx IWidthStmtContext) {
	this := p
	_ = this

	localctx = NewWidthStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, VisualBasic6ParserRULE_widthStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2375)
		p.Match(VisualBasic6ParserWIDTH)
	}
	{
		p.SetState(2376)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2377)
		p.valueStmt(0)
	}
	p.SetState(2379)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2378)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2381)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(2383)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 386, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2382)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2385)
		p.valueStmt(0)
	}

	return localctx
}

// IWithStmtContext is an interface to support dynamic dispatch.
type IWithStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWithStmtContext differentiates from other interfaces.
	IsWithStmtContext()
}

type WithStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWithStmtContext() *WithStmtContext {
	var p = new(WithStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_withStmt
	return p
}

func (*WithStmtContext) IsWithStmtContext() {}

func NewWithStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStmtContext {
	var p = new(WithStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_withStmt

	return p
}

func (s *WithStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *WithStmtContext) WITH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWITH, 0)
}

func (s *WithStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *WithStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *WithStmtContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *WithStmtContext) END_WITH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND_WITH, 0)
}

func (s *WithStmtContext) NEW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEW, 0)
}

func (s *WithStmtContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserNEWLINE)
}

func (s *WithStmtContext) NEWLINE(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEWLINE, i)
}

func (s *WithStmtContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *WithStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WithStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WithStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterWithStmt(s)
	}
}

func (s *WithStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitWithStmt(s)
	}
}

func (p *VisualBasic6Parser) WithStmt() (localctx IWithStmtContext) {
	this := p
	_ = this

	localctx = NewWithStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, VisualBasic6ParserRULE_withStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2387)
		p.Match(VisualBasic6ParserWITH)
	}
	{
		p.SetState(2388)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(2391)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 387, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2389)
			p.Match(VisualBasic6ParserNEW)
		}
		{
			p.SetState(2390)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2393)
		p.ImplicitCallStmt_InStmt()
	}
	p.SetState(2395)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
		{
			p.SetState(2394)
			p.Match(VisualBasic6ParserNEWLINE)
		}

		p.SetState(2397)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(2405)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32))|(1<<(VisualBasic6ParserEXIT_DO-32))|(1<<(VisualBasic6ParserEXIT_FOR-32))|(1<<(VisualBasic6ParserEXIT_FUNCTION-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(VisualBasic6ParserEXIT_PROPERTY-64))|(1<<(VisualBasic6ParserEXIT_SUB-64))|(1<<(VisualBasic6ParserFALSE-64))|(1<<(VisualBasic6ParserFILECOPY-64))|(1<<(VisualBasic6ParserFRIEND-64))|(1<<(VisualBasic6ParserFOR-64))|(1<<(VisualBasic6ParserFUNCTION-64))|(1<<(VisualBasic6ParserGET-64))|(1<<(VisualBasic6ParserGLOBAL-64))|(1<<(VisualBasic6ParserGOSUB-64))|(1<<(VisualBasic6ParserGOTO-64))|(1<<(VisualBasic6ParserIF-64))|(1<<(VisualBasic6ParserIMP-64))|(1<<(VisualBasic6ParserIMPLEMENTS-64))|(1<<(VisualBasic6ParserIN-64))|(1<<(VisualBasic6ParserINPUT-64))|(1<<(VisualBasic6ParserIS-64))|(1<<(VisualBasic6ParserINTEGER-64))|(1<<(VisualBasic6ParserKILL-64))|(1<<(VisualBasic6ParserLOAD-64))|(1<<(VisualBasic6ParserLOCK-64))|(1<<(VisualBasic6ParserLONG-64))|(1<<(VisualBasic6ParserLOOP-64))|(1<<(VisualBasic6ParserLEN-64))|(1<<(VisualBasic6ParserLET-64))|(1<<(VisualBasic6ParserLIB-64))|(1<<(VisualBasic6ParserLIKE-64))|(1<<(VisualBasic6ParserLINE_INPUT-64))|(1<<(VisualBasic6ParserLSET-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(VisualBasic6ParserMACRO_IF-96))|(1<<(VisualBasic6ParserME-96))|(1<<(VisualBasic6ParserMID-96))|(1<<(VisualBasic6ParserMKDIR-96))|(1<<(VisualBasic6ParserMOD-96))|(1<<(VisualBasic6ParserNAME-96))|(1<<(VisualBasic6ParserNEXT-96))|(1<<(VisualBasic6ParserNEW-96))|(1<<(VisualBasic6ParserNOT-96))|(1<<(VisualBasic6ParserNOTHING-96))|(1<<(VisualBasic6ParserNULL_-96))|(1<<(VisualBasic6ParserOBJECT-96))|(1<<(VisualBasic6ParserON-96))|(1<<(VisualBasic6ParserON_ERROR-96))|(1<<(VisualBasic6ParserON_LOCAL_ERROR-96))|(1<<(VisualBasic6ParserOPEN-96))|(1<<(VisualBasic6ParserOPTIONAL-96))|(1<<(VisualBasic6ParserOR-96))|(1<<(VisualBasic6ParserOUTPUT-96))|(1<<(VisualBasic6ParserPARAMARRAY-96))|(1<<(VisualBasic6ParserPRESERVE-96))|(1<<(VisualBasic6ParserPRINT-96))|(1<<(VisualBasic6ParserPRIVATE-96)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(VisualBasic6ParserPUBLIC-129))|(1<<(VisualBasic6ParserPUT-129))|(1<<(VisualBasic6ParserRANDOM-129))|(1<<(VisualBasic6ParserRANDOMIZE-129))|(1<<(VisualBasic6ParserRAISEEVENT-129))|(1<<(VisualBasic6ParserREAD-129))|(1<<(VisualBasic6ParserREDIM-129))|(1<<(VisualBasic6ParserREM-129))|(1<<(VisualBasic6ParserRESET-129))|(1<<(VisualBasic6ParserRESUME-129))|(1<<(VisualBasic6ParserRETURN-129))|(1<<(VisualBasic6ParserRMDIR-129))|(1<<(VisualBasic6ParserRSET-129))|(1<<(VisualBasic6ParserSAVEPICTURE-129))|(1<<(VisualBasic6ParserSAVESETTING-129))|(1<<(VisualBasic6ParserSEEK-129))|(1<<(VisualBasic6ParserSELECT-129))|(1<<(VisualBasic6ParserSENDKEYS-129))|(1<<(VisualBasic6ParserSET-129))|(1<<(VisualBasic6ParserSETATTR-129))|(1<<(VisualBasic6ParserSHARED-129))|(1<<(VisualBasic6ParserSINGLE-129))|(1<<(VisualBasic6ParserSPC-129))|(1<<(VisualBasic6ParserSTATIC-129))|(1<<(VisualBasic6ParserSTEP-129))|(1<<(VisualBasic6ParserSTOP-129))|(1<<(VisualBasic6ParserSTRING-129))|(1<<(VisualBasic6ParserSUB-129))|(1<<(VisualBasic6ParserTAB-129))|(1<<(VisualBasic6ParserTEXT-129))|(1<<(VisualBasic6ParserTHEN-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(VisualBasic6ParserTIME-161))|(1<<(VisualBasic6ParserTO-161))|(1<<(VisualBasic6ParserTRUE-161))|(1<<(VisualBasic6ParserTYPE-161))|(1<<(VisualBasic6ParserTYPEOF-161))|(1<<(VisualBasic6ParserUNLOAD-161))|(1<<(VisualBasic6ParserUNLOCK-161))|(1<<(VisualBasic6ParserUNTIL-161))|(1<<(VisualBasic6ParserVARIANT-161))|(1<<(VisualBasic6ParserVERSION-161))|(1<<(VisualBasic6ParserWEND-161))|(1<<(VisualBasic6ParserWHILE-161))|(1<<(VisualBasic6ParserWIDTH-161))|(1<<(VisualBasic6ParserWITH-161))|(1<<(VisualBasic6ParserWITHEVENTS-161))|(1<<(VisualBasic6ParserWRITE-161))|(1<<(VisualBasic6ParserXOR-161))|(1<<(VisualBasic6ParserDOT-161))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-161)))) != 0) || (((_la-207)&-(0x1f+1)) == 0 && ((1<<uint((_la-207)))&((1<<(VisualBasic6ParserL_SQUARE_BRACKET-207))|(1<<(VisualBasic6ParserIDENTIFIER-207))|(1<<(VisualBasic6ParserWS-207)))) != 0) {
		{
			p.SetState(2399)
			p.Block()
		}
		p.SetState(2401)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == VisualBasic6ParserNEWLINE {
			{
				p.SetState(2400)
				p.Match(VisualBasic6ParserNEWLINE)
			}

			p.SetState(2403)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(2407)
		p.Match(VisualBasic6ParserEND_WITH)
	}

	return localctx
}

// IWriteStmtContext is an interface to support dynamic dispatch.
type IWriteStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWriteStmtContext differentiates from other interfaces.
	IsWriteStmtContext()
}

type WriteStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWriteStmtContext() *WriteStmtContext {
	var p = new(WriteStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_writeStmt
	return p
}

func (*WriteStmtContext) IsWriteStmtContext() {}

func NewWriteStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WriteStmtContext {
	var p = new(WriteStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_writeStmt

	return p
}

func (s *WriteStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *WriteStmtContext) WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWRITE, 0)
}

func (s *WriteStmtContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *WriteStmtContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *WriteStmtContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *WriteStmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, 0)
}

func (s *WriteStmtContext) OutputList() IOutputListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOutputListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOutputListContext)
}

func (s *WriteStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WriteStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WriteStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterWriteStmt(s)
	}
}

func (s *WriteStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitWriteStmt(s)
	}
}

func (p *VisualBasic6Parser) WriteStmt() (localctx IWriteStmtContext) {
	this := p
	_ = this

	localctx = NewWriteStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, VisualBasic6ParserRULE_writeStmt)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2409)
		p.Match(VisualBasic6ParserWRITE)
	}
	{
		p.SetState(2410)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2411)
		p.valueStmt(0)
	}
	p.SetState(2413)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2412)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2415)
		p.Match(VisualBasic6ParserCOMMA)
	}
	p.SetState(2420)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 393, p.GetParserRuleContext()) == 1 {
		p.SetState(2417)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2416)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2419)
			p.OutputList()
		}

	}

	return localctx
}

// IExplicitCallStmtContext is an interface to support dynamic dispatch.
type IExplicitCallStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExplicitCallStmtContext differentiates from other interfaces.
	IsExplicitCallStmtContext()
}

type ExplicitCallStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplicitCallStmtContext() *ExplicitCallStmtContext {
	var p = new(ExplicitCallStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_explicitCallStmt
	return p
}

func (*ExplicitCallStmtContext) IsExplicitCallStmtContext() {}

func NewExplicitCallStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplicitCallStmtContext {
	var p = new(ExplicitCallStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_explicitCallStmt

	return p
}

func (s *ExplicitCallStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ExplicitCallStmtContext) ECS_ProcedureCall() IECS_ProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IECS_ProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IECS_ProcedureCallContext)
}

func (s *ExplicitCallStmtContext) ECS_MemberProcedureCall() IECS_MemberProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IECS_MemberProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IECS_MemberProcedureCallContext)
}

func (s *ExplicitCallStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExplicitCallStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExplicitCallStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterExplicitCallStmt(s)
	}
}

func (s *ExplicitCallStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitExplicitCallStmt(s)
	}
}

func (p *VisualBasic6Parser) ExplicitCallStmt() (localctx IExplicitCallStmtContext) {
	this := p
	_ = this

	localctx = NewExplicitCallStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, VisualBasic6ParserRULE_explicitCallStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2424)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 394, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2422)
			p.ECS_ProcedureCall()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2423)
			p.ECS_MemberProcedureCall()
		}

	}

	return localctx
}

// IECS_ProcedureCallContext is an interface to support dynamic dispatch.
type IECS_ProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsECS_ProcedureCallContext differentiates from other interfaces.
	IsECS_ProcedureCallContext()
}

type ECS_ProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyECS_ProcedureCallContext() *ECS_ProcedureCallContext {
	var p = new(ECS_ProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_eCS_ProcedureCall
	return p
}

func (*ECS_ProcedureCallContext) IsECS_ProcedureCallContext() {}

func NewECS_ProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ECS_ProcedureCallContext {
	var p = new(ECS_ProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_eCS_ProcedureCall

	return p
}

func (s *ECS_ProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ECS_ProcedureCallContext) CALL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCALL, 0)
}

func (s *ECS_ProcedureCallContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ECS_ProcedureCallContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ECS_ProcedureCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ECS_ProcedureCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ECS_ProcedureCallContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *ECS_ProcedureCallContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ECS_ProcedureCallContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *ECS_ProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ECS_ProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ECS_ProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterECS_ProcedureCall(s)
	}
}

func (s *ECS_ProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitECS_ProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ECS_ProcedureCall() (localctx IECS_ProcedureCallContext) {
	this := p
	_ = this

	localctx = NewECS_ProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, VisualBasic6ParserRULE_eCS_ProcedureCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2426)
		p.Match(VisualBasic6ParserCALL)
	}
	{
		p.SetState(2427)
		p.Match(VisualBasic6ParserWS)
	}
	{
		p.SetState(2428)
		p.AmbiguousIdentifier()
	}
	p.SetState(2430)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2429)
			p.TypeHint()
		}

	}
	p.SetState(2445)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 399, p.GetParserRuleContext()) == 1 {
		p.SetState(2433)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2432)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2435)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2437)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 397, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2436)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2439)
			p.ArgsCall()
		}
		p.SetState(2441)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2440)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2443)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}

	return localctx
}

// IECS_MemberProcedureCallContext is an interface to support dynamic dispatch.
type IECS_MemberProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsECS_MemberProcedureCallContext differentiates from other interfaces.
	IsECS_MemberProcedureCallContext()
}

type ECS_MemberProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyECS_MemberProcedureCallContext() *ECS_MemberProcedureCallContext {
	var p = new(ECS_MemberProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_eCS_MemberProcedureCall
	return p
}

func (*ECS_MemberProcedureCallContext) IsECS_MemberProcedureCallContext() {}

func NewECS_MemberProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ECS_MemberProcedureCallContext {
	var p = new(ECS_MemberProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_eCS_MemberProcedureCall

	return p
}

func (s *ECS_MemberProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ECS_MemberProcedureCallContext) CALL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCALL, 0)
}

func (s *ECS_MemberProcedureCallContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ECS_MemberProcedureCallContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ECS_MemberProcedureCallContext) DOT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOT, 0)
}

func (s *ECS_MemberProcedureCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ECS_MemberProcedureCallContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *ECS_MemberProcedureCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ECS_MemberProcedureCallContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *ECS_MemberProcedureCallContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ECS_MemberProcedureCallContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *ECS_MemberProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ECS_MemberProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ECS_MemberProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterECS_MemberProcedureCall(s)
	}
}

func (s *ECS_MemberProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitECS_MemberProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ECS_MemberProcedureCall() (localctx IECS_MemberProcedureCallContext) {
	this := p
	_ = this

	localctx = NewECS_MemberProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, VisualBasic6ParserRULE_eCS_MemberProcedureCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2447)
		p.Match(VisualBasic6ParserCALL)
	}
	{
		p.SetState(2448)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(2450)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 400, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2449)
			p.ImplicitCallStmt_InStmt()
		}

	}
	{
		p.SetState(2452)
		p.Match(VisualBasic6ParserDOT)
	}
	p.SetState(2454)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2453)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2456)
		p.AmbiguousIdentifier()
	}
	p.SetState(2458)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 402, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2457)
			p.TypeHint()
		}

	}
	p.SetState(2473)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 406, p.GetParserRuleContext()) == 1 {
		p.SetState(2461)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2460)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2463)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2465)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 404, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2464)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2467)
			p.ArgsCall()
		}
		p.SetState(2469)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2468)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2471)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}

	return localctx
}

// IImplicitCallStmt_InBlockContext is an interface to support dynamic dispatch.
type IImplicitCallStmt_InBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsImplicitCallStmt_InBlockContext differentiates from other interfaces.
	IsImplicitCallStmt_InBlockContext()
}

type ImplicitCallStmt_InBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImplicitCallStmt_InBlockContext() *ImplicitCallStmt_InBlockContext {
	var p = new(ImplicitCallStmt_InBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_implicitCallStmt_InBlock
	return p
}

func (*ImplicitCallStmt_InBlockContext) IsImplicitCallStmt_InBlockContext() {}

func NewImplicitCallStmt_InBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplicitCallStmt_InBlockContext {
	var p = new(ImplicitCallStmt_InBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_implicitCallStmt_InBlock

	return p
}

func (s *ImplicitCallStmt_InBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *ImplicitCallStmt_InBlockContext) ICS_B_ProcedureCall() IICS_B_ProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_B_ProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_B_ProcedureCallContext)
}

func (s *ImplicitCallStmt_InBlockContext) ICS_B_MemberProcedureCall() IICS_B_MemberProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_B_MemberProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_B_MemberProcedureCallContext)
}

func (s *ImplicitCallStmt_InBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImplicitCallStmt_InBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImplicitCallStmt_InBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterImplicitCallStmt_InBlock(s)
	}
}

func (s *ImplicitCallStmt_InBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitImplicitCallStmt_InBlock(s)
	}
}

func (p *VisualBasic6Parser) ImplicitCallStmt_InBlock() (localctx IImplicitCallStmt_InBlockContext) {
	this := p
	_ = this

	localctx = NewImplicitCallStmt_InBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, VisualBasic6ParserRULE_implicitCallStmt_InBlock)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2477)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 407, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2475)
			p.ICS_B_ProcedureCall()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2476)
			p.ICS_B_MemberProcedureCall()
		}

	}

	return localctx
}

// IICS_B_ProcedureCallContext is an interface to support dynamic dispatch.
type IICS_B_ProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_B_ProcedureCallContext differentiates from other interfaces.
	IsICS_B_ProcedureCallContext()
}

type ICS_B_ProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_B_ProcedureCallContext() *ICS_B_ProcedureCallContext {
	var p = new(ICS_B_ProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_B_ProcedureCall
	return p
}

func (*ICS_B_ProcedureCallContext) IsICS_B_ProcedureCallContext() {}

func NewICS_B_ProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_B_ProcedureCallContext {
	var p = new(ICS_B_ProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_B_ProcedureCall

	return p
}

func (s *ICS_B_ProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_B_ProcedureCallContext) CertainIdentifier() ICertainIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICertainIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICertainIdentifierContext)
}

func (s *ICS_B_ProcedureCallContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ICS_B_ProcedureCallContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ICS_B_ProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_B_ProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_B_ProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_B_ProcedureCall(s)
	}
}

func (s *ICS_B_ProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_B_ProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_B_ProcedureCall() (localctx IICS_B_ProcedureCallContext) {
	this := p
	_ = this

	localctx = NewICS_B_ProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, VisualBasic6ParserRULE_iCS_B_ProcedureCall)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2479)
		p.CertainIdentifier()
	}
	p.SetState(2482)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 408, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2480)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2481)
			p.ArgsCall()
		}

	}

	return localctx
}

// IICS_B_MemberProcedureCallContext is an interface to support dynamic dispatch.
type IICS_B_MemberProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_B_MemberProcedureCallContext differentiates from other interfaces.
	IsICS_B_MemberProcedureCallContext()
}

type ICS_B_MemberProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_B_MemberProcedureCallContext() *ICS_B_MemberProcedureCallContext {
	var p = new(ICS_B_MemberProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_B_MemberProcedureCall
	return p
}

func (*ICS_B_MemberProcedureCallContext) IsICS_B_MemberProcedureCallContext() {}

func NewICS_B_MemberProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_B_MemberProcedureCallContext {
	var p = new(ICS_B_MemberProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_B_MemberProcedureCall

	return p
}

func (s *ICS_B_MemberProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_B_MemberProcedureCallContext) DOT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOT, 0)
}

func (s *ICS_B_MemberProcedureCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ICS_B_MemberProcedureCallContext) ImplicitCallStmt_InStmt() IImplicitCallStmt_InStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplicitCallStmt_InStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplicitCallStmt_InStmtContext)
}

func (s *ICS_B_MemberProcedureCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ICS_B_MemberProcedureCallContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ICS_B_MemberProcedureCallContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ICS_B_MemberProcedureCallContext) DictionaryCallStmt() IDictionaryCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDictionaryCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDictionaryCallStmtContext)
}

func (s *ICS_B_MemberProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_B_MemberProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_B_MemberProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_B_MemberProcedureCall(s)
	}
}

func (s *ICS_B_MemberProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_B_MemberProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_B_MemberProcedureCall() (localctx IICS_B_MemberProcedureCallContext) {
	this := p
	_ = this

	localctx = NewICS_B_MemberProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, VisualBasic6ParserRULE_iCS_B_MemberProcedureCall)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2485)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 409, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2484)
			p.ImplicitCallStmt_InStmt()
		}

	}
	{
		p.SetState(2487)
		p.Match(VisualBasic6ParserDOT)
	}
	{
		p.SetState(2488)
		p.AmbiguousIdentifier()
	}
	p.SetState(2490)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 410, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2489)
			p.TypeHint()
		}

	}
	p.SetState(2494)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 411, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2492)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2493)
			p.ArgsCall()
		}

	}
	p.SetState(2497)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 412, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2496)
			p.DictionaryCallStmt()
		}

	}

	return localctx
}

// IImplicitCallStmt_InStmtContext is an interface to support dynamic dispatch.
type IImplicitCallStmt_InStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsImplicitCallStmt_InStmtContext differentiates from other interfaces.
	IsImplicitCallStmt_InStmtContext()
}

type ImplicitCallStmt_InStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImplicitCallStmt_InStmtContext() *ImplicitCallStmt_InStmtContext {
	var p = new(ImplicitCallStmt_InStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_implicitCallStmt_InStmt
	return p
}

func (*ImplicitCallStmt_InStmtContext) IsImplicitCallStmt_InStmtContext() {}

func NewImplicitCallStmt_InStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplicitCallStmt_InStmtContext {
	var p = new(ImplicitCallStmt_InStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_implicitCallStmt_InStmt

	return p
}

func (s *ImplicitCallStmt_InStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *ImplicitCallStmt_InStmtContext) ICS_S_MembersCall() IICS_S_MembersCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_MembersCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_MembersCallContext)
}

func (s *ImplicitCallStmt_InStmtContext) ICS_S_VariableOrProcedureCall() IICS_S_VariableOrProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_VariableOrProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_VariableOrProcedureCallContext)
}

func (s *ImplicitCallStmt_InStmtContext) ICS_S_ProcedureOrArrayCall() IICS_S_ProcedureOrArrayCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_ProcedureOrArrayCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_ProcedureOrArrayCallContext)
}

func (s *ImplicitCallStmt_InStmtContext) ICS_S_DictionaryCall() IICS_S_DictionaryCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_DictionaryCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_DictionaryCallContext)
}

func (s *ImplicitCallStmt_InStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImplicitCallStmt_InStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImplicitCallStmt_InStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterImplicitCallStmt_InStmt(s)
	}
}

func (s *ImplicitCallStmt_InStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitImplicitCallStmt_InStmt(s)
	}
}

func (p *VisualBasic6Parser) ImplicitCallStmt_InStmt() (localctx IImplicitCallStmt_InStmtContext) {
	this := p
	_ = this

	localctx = NewImplicitCallStmt_InStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 248, VisualBasic6ParserRULE_implicitCallStmt_InStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2503)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 413, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2499)
			p.ICS_S_MembersCall()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2500)
			p.ICS_S_VariableOrProcedureCall()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2501)
			p.ICS_S_ProcedureOrArrayCall()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2502)
			p.ICS_S_DictionaryCall()
		}

	}

	return localctx
}

// IICS_S_VariableOrProcedureCallContext is an interface to support dynamic dispatch.
type IICS_S_VariableOrProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_VariableOrProcedureCallContext differentiates from other interfaces.
	IsICS_S_VariableOrProcedureCallContext()
}

type ICS_S_VariableOrProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_VariableOrProcedureCallContext() *ICS_S_VariableOrProcedureCallContext {
	var p = new(ICS_S_VariableOrProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_VariableOrProcedureCall
	return p
}

func (*ICS_S_VariableOrProcedureCallContext) IsICS_S_VariableOrProcedureCallContext() {}

func NewICS_S_VariableOrProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_VariableOrProcedureCallContext {
	var p = new(ICS_S_VariableOrProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_VariableOrProcedureCall

	return p
}

func (s *ICS_S_VariableOrProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_VariableOrProcedureCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ICS_S_VariableOrProcedureCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ICS_S_VariableOrProcedureCallContext) DictionaryCallStmt() IDictionaryCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDictionaryCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDictionaryCallStmtContext)
}

func (s *ICS_S_VariableOrProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_VariableOrProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_VariableOrProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_VariableOrProcedureCall(s)
	}
}

func (s *ICS_S_VariableOrProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_VariableOrProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_VariableOrProcedureCall() (localctx IICS_S_VariableOrProcedureCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_VariableOrProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 250, VisualBasic6ParserRULE_iCS_S_VariableOrProcedureCall)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2505)
		p.AmbiguousIdentifier()
	}
	p.SetState(2507)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 414, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2506)
			p.TypeHint()
		}

	}
	p.SetState(2510)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 415, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2509)
			p.DictionaryCallStmt()
		}

	}

	return localctx
}

// IICS_S_ProcedureOrArrayCallContext is an interface to support dynamic dispatch.
type IICS_S_ProcedureOrArrayCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_ProcedureOrArrayCallContext differentiates from other interfaces.
	IsICS_S_ProcedureOrArrayCallContext()
}

type ICS_S_ProcedureOrArrayCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_ProcedureOrArrayCallContext() *ICS_S_ProcedureOrArrayCallContext {
	var p = new(ICS_S_ProcedureOrArrayCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_ProcedureOrArrayCall
	return p
}

func (*ICS_S_ProcedureOrArrayCallContext) IsICS_S_ProcedureOrArrayCallContext() {}

func NewICS_S_ProcedureOrArrayCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_ProcedureOrArrayCallContext {
	var p = new(ICS_S_ProcedureOrArrayCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_ProcedureOrArrayCall

	return p
}

func (s *ICS_S_ProcedureOrArrayCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_ProcedureOrArrayCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) BaseType() IBaseTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBaseTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBaseTypeContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) ICS_S_NestedProcedureCall() IICS_S_NestedProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_NestedProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_NestedProcedureCallContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ICS_S_ProcedureOrArrayCallContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ICS_S_ProcedureOrArrayCallContext) AllLPAREN() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserLPAREN)
}

func (s *ICS_S_ProcedureOrArrayCallContext) LPAREN(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, i)
}

func (s *ICS_S_ProcedureOrArrayCallContext) AllRPAREN() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserRPAREN)
}

func (s *ICS_S_ProcedureOrArrayCallContext) RPAREN(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, i)
}

func (s *ICS_S_ProcedureOrArrayCallContext) DictionaryCallStmt() IDictionaryCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDictionaryCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDictionaryCallStmtContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) AllArgsCall() []IArgsCallContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArgsCallContext)(nil)).Elem())
	var tst = make([]IArgsCallContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IArgsCallContext)
		}
	}

	return tst
}

func (s *ICS_S_ProcedureOrArrayCallContext) ArgsCall(i int) IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ICS_S_ProcedureOrArrayCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_ProcedureOrArrayCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_ProcedureOrArrayCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_ProcedureOrArrayCall(s)
	}
}

func (s *ICS_S_ProcedureOrArrayCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_ProcedureOrArrayCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_ProcedureOrArrayCall() (localctx IICS_S_ProcedureOrArrayCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_ProcedureOrArrayCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 252, VisualBasic6ParserRULE_iCS_S_ProcedureOrArrayCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2515)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 416, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2512)
			p.AmbiguousIdentifier()
		}

	case 2:
		{
			p.SetState(2513)
			p.BaseType()
		}

	case 3:
		{
			p.SetState(2514)
			p.ICS_S_NestedProcedureCall()
		}

	}
	p.SetState(2518)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(2517)
			p.TypeHint()
		}

	}
	p.SetState(2521)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2520)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2534)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(2523)
				p.Match(VisualBasic6ParserLPAREN)
			}
			p.SetState(2525)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 419, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2524)
					p.Match(VisualBasic6ParserWS)
				}

			}
			p.SetState(2531)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserCOMMA-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164))|(1<<(VisualBasic6ParserLPAREN-164)))) != 0) || (((_la-196)&-(0x1f+1)) == 0 && ((1<<uint((_la-196)))&((1<<(VisualBasic6ParserMINUS-196))|(1<<(VisualBasic6ParserPLUS-196))|(1<<(VisualBasic6ParserSEMICOLON-196))|(1<<(VisualBasic6ParserL_SQUARE_BRACKET-196))|(1<<(VisualBasic6ParserSTRINGLITERAL-196))|(1<<(VisualBasic6ParserDATELITERAL-196))|(1<<(VisualBasic6ParserCOLORLITERAL-196))|(1<<(VisualBasic6ParserINTEGERLITERAL-196))|(1<<(VisualBasic6ParserDOUBLELITERAL-196))|(1<<(VisualBasic6ParserFILENUMBER-196))|(1<<(VisualBasic6ParserOCTALLITERAL-196))|(1<<(VisualBasic6ParserIDENTIFIER-196))|(1<<(VisualBasic6ParserWS-196)))) != 0) {
				{
					p.SetState(2527)
					p.ArgsCall()
				}
				p.SetState(2529)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2528)
						p.Match(VisualBasic6ParserWS)
					}

				}

			}
			{
				p.SetState(2533)
				p.Match(VisualBasic6ParserRPAREN)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(2536)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 422, p.GetParserRuleContext())
	}
	p.SetState(2539)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 423, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2538)
			p.DictionaryCallStmt()
		}

	}

	return localctx
}

// IICS_S_NestedProcedureCallContext is an interface to support dynamic dispatch.
type IICS_S_NestedProcedureCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_NestedProcedureCallContext differentiates from other interfaces.
	IsICS_S_NestedProcedureCallContext()
}

type ICS_S_NestedProcedureCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_NestedProcedureCallContext() *ICS_S_NestedProcedureCallContext {
	var p = new(ICS_S_NestedProcedureCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_NestedProcedureCall
	return p
}

func (*ICS_S_NestedProcedureCallContext) IsICS_S_NestedProcedureCallContext() {}

func NewICS_S_NestedProcedureCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_NestedProcedureCallContext {
	var p = new(ICS_S_NestedProcedureCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_NestedProcedureCall

	return p
}

func (s *ICS_S_NestedProcedureCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_NestedProcedureCallContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ICS_S_NestedProcedureCallContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *ICS_S_NestedProcedureCallContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *ICS_S_NestedProcedureCallContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ICS_S_NestedProcedureCallContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ICS_S_NestedProcedureCallContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ICS_S_NestedProcedureCallContext) ArgsCall() IArgsCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgsCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgsCallContext)
}

func (s *ICS_S_NestedProcedureCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_NestedProcedureCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_NestedProcedureCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_NestedProcedureCall(s)
	}
}

func (s *ICS_S_NestedProcedureCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_NestedProcedureCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_NestedProcedureCall() (localctx IICS_S_NestedProcedureCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_NestedProcedureCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 254, VisualBasic6ParserRULE_iCS_S_NestedProcedureCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2541)
		p.AmbiguousIdentifier()
	}
	p.SetState(2543)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(2542)
			p.TypeHint()
		}

	}
	p.SetState(2546)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2545)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2548)
		p.Match(VisualBasic6ParserLPAREN)
	}
	p.SetState(2550)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 426, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2549)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2556)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164))|(1<<(VisualBasic6ParserCOMMA-164))|(1<<(VisualBasic6ParserDOT-164))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-164))|(1<<(VisualBasic6ParserLPAREN-164)))) != 0) || (((_la-196)&-(0x1f+1)) == 0 && ((1<<uint((_la-196)))&((1<<(VisualBasic6ParserMINUS-196))|(1<<(VisualBasic6ParserPLUS-196))|(1<<(VisualBasic6ParserSEMICOLON-196))|(1<<(VisualBasic6ParserL_SQUARE_BRACKET-196))|(1<<(VisualBasic6ParserSTRINGLITERAL-196))|(1<<(VisualBasic6ParserDATELITERAL-196))|(1<<(VisualBasic6ParserCOLORLITERAL-196))|(1<<(VisualBasic6ParserINTEGERLITERAL-196))|(1<<(VisualBasic6ParserDOUBLELITERAL-196))|(1<<(VisualBasic6ParserFILENUMBER-196))|(1<<(VisualBasic6ParserOCTALLITERAL-196))|(1<<(VisualBasic6ParserIDENTIFIER-196))|(1<<(VisualBasic6ParserWS-196)))) != 0) {
		{
			p.SetState(2552)
			p.ArgsCall()
		}
		p.SetState(2554)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2553)
				p.Match(VisualBasic6ParserWS)
			}

		}

	}
	{
		p.SetState(2558)
		p.Match(VisualBasic6ParserRPAREN)
	}

	return localctx
}

// IICS_S_MembersCallContext is an interface to support dynamic dispatch.
type IICS_S_MembersCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_MembersCallContext differentiates from other interfaces.
	IsICS_S_MembersCallContext()
}

type ICS_S_MembersCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_MembersCallContext() *ICS_S_MembersCallContext {
	var p = new(ICS_S_MembersCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_MembersCall
	return p
}

func (*ICS_S_MembersCallContext) IsICS_S_MembersCallContext() {}

func NewICS_S_MembersCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_MembersCallContext {
	var p = new(ICS_S_MembersCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_MembersCall

	return p
}

func (s *ICS_S_MembersCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_MembersCallContext) ICS_S_VariableOrProcedureCall() IICS_S_VariableOrProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_VariableOrProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_VariableOrProcedureCallContext)
}

func (s *ICS_S_MembersCallContext) ICS_S_ProcedureOrArrayCall() IICS_S_ProcedureOrArrayCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_ProcedureOrArrayCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_ProcedureOrArrayCallContext)
}

func (s *ICS_S_MembersCallContext) AllICS_S_MemberCall() []IICS_S_MemberCallContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IICS_S_MemberCallContext)(nil)).Elem())
	var tst = make([]IICS_S_MemberCallContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IICS_S_MemberCallContext)
		}
	}

	return tst
}

func (s *ICS_S_MembersCallContext) ICS_S_MemberCall(i int) IICS_S_MemberCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_MemberCallContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IICS_S_MemberCallContext)
}

func (s *ICS_S_MembersCallContext) DictionaryCallStmt() IDictionaryCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDictionaryCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDictionaryCallStmtContext)
}

func (s *ICS_S_MembersCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_MembersCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_MembersCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_MembersCall(s)
	}
}

func (s *ICS_S_MembersCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_MembersCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_MembersCall() (localctx IICS_S_MembersCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_MembersCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 256, VisualBasic6ParserRULE_iCS_S_MembersCall)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2562)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 429, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2560)
			p.ICS_S_VariableOrProcedureCall()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 429, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(2561)
			p.ICS_S_ProcedureOrArrayCall()
		}

	}
	p.SetState(2565)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(2564)
				p.ICS_S_MemberCall()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(2567)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 430, p.GetParserRuleContext())
	}
	p.SetState(2570)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 431, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2569)
			p.DictionaryCallStmt()
		}

	}

	return localctx
}

// IICS_S_MemberCallContext is an interface to support dynamic dispatch.
type IICS_S_MemberCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_MemberCallContext differentiates from other interfaces.
	IsICS_S_MemberCallContext()
}

type ICS_S_MemberCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_MemberCallContext() *ICS_S_MemberCallContext {
	var p = new(ICS_S_MemberCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_MemberCall
	return p
}

func (*ICS_S_MemberCallContext) IsICS_S_MemberCallContext() {}

func NewICS_S_MemberCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_MemberCallContext {
	var p = new(ICS_S_MemberCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_MemberCall

	return p
}

func (s *ICS_S_MemberCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_MemberCallContext) DOT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOT, 0)
}

func (s *ICS_S_MemberCallContext) ICS_S_VariableOrProcedureCall() IICS_S_VariableOrProcedureCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_VariableOrProcedureCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_VariableOrProcedureCallContext)
}

func (s *ICS_S_MemberCallContext) ICS_S_ProcedureOrArrayCall() IICS_S_ProcedureOrArrayCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IICS_S_ProcedureOrArrayCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IICS_S_ProcedureOrArrayCallContext)
}

func (s *ICS_S_MemberCallContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ICS_S_MemberCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_MemberCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_MemberCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_MemberCall(s)
	}
}

func (s *ICS_S_MemberCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_MemberCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_MemberCall() (localctx IICS_S_MemberCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_MemberCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 258, VisualBasic6ParserRULE_iCS_S_MemberCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2573)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2572)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2575)
		p.Match(VisualBasic6ParserDOT)
	}
	p.SetState(2578)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 433, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2576)
			p.ICS_S_VariableOrProcedureCall()
		}

	case 2:
		{
			p.SetState(2577)
			p.ICS_S_ProcedureOrArrayCall()
		}

	}

	return localctx
}

// IICS_S_DictionaryCallContext is an interface to support dynamic dispatch.
type IICS_S_DictionaryCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsICS_S_DictionaryCallContext differentiates from other interfaces.
	IsICS_S_DictionaryCallContext()
}

type ICS_S_DictionaryCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyICS_S_DictionaryCallContext() *ICS_S_DictionaryCallContext {
	var p = new(ICS_S_DictionaryCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_DictionaryCall
	return p
}

func (*ICS_S_DictionaryCallContext) IsICS_S_DictionaryCallContext() {}

func NewICS_S_DictionaryCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ICS_S_DictionaryCallContext {
	var p = new(ICS_S_DictionaryCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_iCS_S_DictionaryCall

	return p
}

func (s *ICS_S_DictionaryCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ICS_S_DictionaryCallContext) DictionaryCallStmt() IDictionaryCallStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDictionaryCallStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDictionaryCallStmtContext)
}

func (s *ICS_S_DictionaryCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ICS_S_DictionaryCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ICS_S_DictionaryCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterICS_S_DictionaryCall(s)
	}
}

func (s *ICS_S_DictionaryCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitICS_S_DictionaryCall(s)
	}
}

func (p *VisualBasic6Parser) ICS_S_DictionaryCall() (localctx IICS_S_DictionaryCallContext) {
	this := p
	_ = this

	localctx = NewICS_S_DictionaryCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 260, VisualBasic6ParserRULE_iCS_S_DictionaryCall)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2580)
		p.DictionaryCallStmt()
	}

	return localctx
}

// IArgsCallContext is an interface to support dynamic dispatch.
type IArgsCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgsCallContext differentiates from other interfaces.
	IsArgsCallContext()
}

type ArgsCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgsCallContext() *ArgsCallContext {
	var p = new(ArgsCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_argsCall
	return p
}

func (*ArgsCallContext) IsArgsCallContext() {}

func NewArgsCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgsCallContext {
	var p = new(ArgsCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_argsCall

	return p
}

func (s *ArgsCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgsCallContext) AllArgCall() []IArgCallContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArgCallContext)(nil)).Elem())
	var tst = make([]IArgCallContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IArgCallContext)
		}
	}

	return tst
}

func (s *ArgsCallContext) ArgCall(i int) IArgCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgCallContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArgCallContext)
}

func (s *ArgsCallContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *ArgsCallContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *ArgsCallContext) AllSEMICOLON() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserSEMICOLON)
}

func (s *ArgsCallContext) SEMICOLON(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSEMICOLON, i)
}

func (s *ArgsCallContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ArgsCallContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ArgsCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgsCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgsCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterArgsCall(s)
	}
}

func (s *ArgsCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitArgsCall(s)
	}
}

func (p *VisualBasic6Parser) ArgsCall() (localctx IArgsCallContext) {
	this := p
	_ = this

	localctx = NewArgsCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 262, VisualBasic6ParserRULE_argsCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2594)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 437, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(2583)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 434, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2582)
					p.ArgCall()
				}

			}
			p.SetState(2586)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2585)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2588)
				_la = p.GetTokenStream().LA(1)

				if !(_la == VisualBasic6ParserCOMMA || _la == VisualBasic6ParserSEMICOLON) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			p.SetState(2590)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 436, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2589)
					p.Match(VisualBasic6ParserWS)
				}

			}

		}
		p.SetState(2596)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 437, p.GetParserRuleContext())
	}
	{
		p.SetState(2597)
		p.ArgCall()
	}
	p.SetState(2610)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 441, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(2599)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2598)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2601)
				_la = p.GetTokenStream().LA(1)

				if !(_la == VisualBasic6ParserCOMMA || _la == VisualBasic6ParserSEMICOLON) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			p.SetState(2603)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 439, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2602)
					p.Match(VisualBasic6ParserWS)
				}

			}
			p.SetState(2606)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2605)
					p.ArgCall()
				}

			}

		}
		p.SetState(2612)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 441, p.GetParserRuleContext())
	}

	return localctx
}

// IArgCallContext is an interface to support dynamic dispatch.
type IArgCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgCallContext differentiates from other interfaces.
	IsArgCallContext()
}

type ArgCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgCallContext() *ArgCallContext {
	var p = new(ArgCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_argCall
	return p
}

func (*ArgCallContext) IsArgCallContext() {}

func NewArgCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgCallContext {
	var p = new(ArgCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_argCall

	return p
}

func (s *ArgCallContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgCallContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ArgCallContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ArgCallContext) BYVAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYVAL, 0)
}

func (s *ArgCallContext) BYREF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYREF, 0)
}

func (s *ArgCallContext) PARAMARRAY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPARAMARRAY, 0)
}

func (s *ArgCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterArgCall(s)
	}
}

func (s *ArgCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitArgCall(s)
	}
}

func (p *VisualBasic6Parser) ArgCall() (localctx IArgCallContext) {
	this := p
	_ = this

	localctx = NewArgCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 264, VisualBasic6ParserRULE_argCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2615)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2613)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserBYVAL || _la == VisualBasic6ParserBYREF || _la == VisualBasic6ParserPARAMARRAY) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(2614)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2617)
		p.valueStmt(0)
	}

	return localctx
}

// IDictionaryCallStmtContext is an interface to support dynamic dispatch.
type IDictionaryCallStmtContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDictionaryCallStmtContext differentiates from other interfaces.
	IsDictionaryCallStmtContext()
}

type DictionaryCallStmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDictionaryCallStmtContext() *DictionaryCallStmtContext {
	var p = new(DictionaryCallStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_dictionaryCallStmt
	return p
}

func (*DictionaryCallStmtContext) IsDictionaryCallStmtContext() {}

func NewDictionaryCallStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryCallStmtContext {
	var p = new(DictionaryCallStmtContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_dictionaryCallStmt

	return p
}

func (s *DictionaryCallStmtContext) GetParser() antlr.Parser { return s.parser }

func (s *DictionaryCallStmtContext) EXCLAMATIONMARK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXCLAMATIONMARK, 0)
}

func (s *DictionaryCallStmtContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *DictionaryCallStmtContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *DictionaryCallStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DictionaryCallStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DictionaryCallStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterDictionaryCallStmt(s)
	}
}

func (s *DictionaryCallStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitDictionaryCallStmt(s)
	}
}

func (p *VisualBasic6Parser) DictionaryCallStmt() (localctx IDictionaryCallStmtContext) {
	this := p
	_ = this

	localctx = NewDictionaryCallStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 266, VisualBasic6ParserRULE_dictionaryCallStmt)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2619)
		p.Match(VisualBasic6ParserEXCLAMATIONMARK)
	}
	{
		p.SetState(2620)
		p.AmbiguousIdentifier()
	}
	p.SetState(2622)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 443, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2621)
			p.TypeHint()
		}

	}

	return localctx
}

// IArgListContext is an interface to support dynamic dispatch.
type IArgListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgListContext differentiates from other interfaces.
	IsArgListContext()
}

type ArgListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgListContext() *ArgListContext {
	var p = new(ArgListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_argList
	return p
}

func (*ArgListContext) IsArgListContext() {}

func NewArgListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgListContext {
	var p = new(ArgListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_argList

	return p
}

func (s *ArgListContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgListContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *ArgListContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *ArgListContext) AllArg() []IArgContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArgContext)(nil)).Elem())
	var tst = make([]IArgContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IArgContext)
		}
	}

	return tst
}

func (s *ArgListContext) Arg(i int) IArgContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArgContext)
}

func (s *ArgListContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ArgListContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ArgListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *ArgListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *ArgListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterArgList(s)
	}
}

func (s *ArgListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitArgList(s)
	}
}

func (p *VisualBasic6Parser) ArgList() (localctx IArgListContext) {
	this := p
	_ = this

	localctx = NewArgListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 268, VisualBasic6ParserRULE_argList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2624)
		p.Match(VisualBasic6ParserLPAREN)
	}
	p.SetState(2642)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 448, p.GetParserRuleContext()) == 1 {
		p.SetState(2626)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2625)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2628)
			p.Arg()
		}
		p.SetState(2639)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 447, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(2630)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2629)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2632)
					p.Match(VisualBasic6ParserCOMMA)
				}
				p.SetState(2634)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == VisualBasic6ParserWS {
					{
						p.SetState(2633)
						p.Match(VisualBasic6ParserWS)
					}

				}
				{
					p.SetState(2636)
					p.Arg()
				}

			}
			p.SetState(2641)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 447, p.GetParserRuleContext())
		}

	}
	p.SetState(2645)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2644)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2647)
		p.Match(VisualBasic6ParserRPAREN)
	}

	return localctx
}

// IArgContext is an interface to support dynamic dispatch.
type IArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgContext differentiates from other interfaces.
	IsArgContext()
}

type ArgContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgContext() *ArgContext {
	var p = new(ArgContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_arg
	return p
}

func (*ArgContext) IsArgContext() {}

func NewArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgContext {
	var p = new(ArgContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_arg

	return p
}

func (s *ArgContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ArgContext) OPTIONAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTIONAL, 0)
}

func (s *ArgContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *ArgContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *ArgContext) PARAMARRAY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPARAMARRAY, 0)
}

func (s *ArgContext) TypeHint() ITypeHintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeHintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeHintContext)
}

func (s *ArgContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *ArgContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *ArgContext) AsTypeClause() IAsTypeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsTypeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsTypeClauseContext)
}

func (s *ArgContext) ArgDefaultValue() IArgDefaultValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgDefaultValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgDefaultValueContext)
}

func (s *ArgContext) BYVAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYVAL, 0)
}

func (s *ArgContext) BYREF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYREF, 0)
}

func (s *ArgContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterArg(s)
	}
}

func (s *ArgContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitArg(s)
	}
}

func (p *VisualBasic6Parser) Arg() (localctx IArgContext) {
	this := p
	_ = this

	localctx = NewArgContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 270, VisualBasic6ParserRULE_arg)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2651)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 450, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2649)
			p.Match(VisualBasic6ParserOPTIONAL)
		}
		{
			p.SetState(2650)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2655)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 451, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2653)
			_la = p.GetTokenStream().LA(1)

			if !(_la == VisualBasic6ParserBYVAL || _la == VisualBasic6ParserBYREF) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(2654)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2659)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 452, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2657)
			p.Match(VisualBasic6ParserPARAMARRAY)
		}
		{
			p.SetState(2658)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2661)
		p.AmbiguousIdentifier()
	}
	p.SetState(2663)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0 {
		{
			p.SetState(2662)
			p.TypeHint()
		}

	}
	p.SetState(2673)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 456, p.GetParserRuleContext()) == 1 {
		p.SetState(2666)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2665)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2668)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2670)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2669)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2672)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}
	p.SetState(2677)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 457, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2675)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2676)
			p.AsTypeClause()
		}

	}
	p.SetState(2683)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 459, p.GetParserRuleContext()) == 1 {
		p.SetState(2680)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2679)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2682)
			p.ArgDefaultValue()
		}

	}

	return localctx
}

// IArgDefaultValueContext is an interface to support dynamic dispatch.
type IArgDefaultValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgDefaultValueContext differentiates from other interfaces.
	IsArgDefaultValueContext()
}

type ArgDefaultValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgDefaultValueContext() *ArgDefaultValueContext {
	var p = new(ArgDefaultValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_argDefaultValue
	return p
}

func (*ArgDefaultValueContext) IsArgDefaultValueContext() {}

func NewArgDefaultValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgDefaultValueContext {
	var p = new(ArgDefaultValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_argDefaultValue

	return p
}

func (s *ArgDefaultValueContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgDefaultValueContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ArgDefaultValueContext) ValueStmt() IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *ArgDefaultValueContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *ArgDefaultValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgDefaultValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgDefaultValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterArgDefaultValue(s)
	}
}

func (s *ArgDefaultValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitArgDefaultValue(s)
	}
}

func (p *VisualBasic6Parser) ArgDefaultValue() (localctx IArgDefaultValueContext) {
	this := p
	_ = this

	localctx = NewArgDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 272, VisualBasic6ParserRULE_argDefaultValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2685)
		p.Match(VisualBasic6ParserEQ)
	}
	p.SetState(2687)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 460, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2686)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2689)
		p.valueStmt(0)
	}

	return localctx
}

// ISubscriptsContext is an interface to support dynamic dispatch.
type ISubscriptsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubscriptsContext differentiates from other interfaces.
	IsSubscriptsContext()
}

type SubscriptsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubscriptsContext() *SubscriptsContext {
	var p = new(SubscriptsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_subscripts
	return p
}

func (*SubscriptsContext) IsSubscriptsContext() {}

func NewSubscriptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubscriptsContext {
	var p = new(SubscriptsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_subscripts

	return p
}

func (s *SubscriptsContext) GetParser() antlr.Parser { return s.parser }

func (s *SubscriptsContext) AllSubscript_() []ISubscript_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISubscript_Context)(nil)).Elem())
	var tst = make([]ISubscript_Context, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISubscript_Context)
		}
	}

	return tst
}

func (s *SubscriptsContext) Subscript_(i int) ISubscript_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubscript_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISubscript_Context)
}

func (s *SubscriptsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserCOMMA)
}

func (s *SubscriptsContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOMMA, i)
}

func (s *SubscriptsContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *SubscriptsContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *SubscriptsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SubscriptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SubscriptsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSubscripts(s)
	}
}

func (s *SubscriptsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSubscripts(s)
	}
}

func (p *VisualBasic6Parser) Subscripts() (localctx ISubscriptsContext) {
	this := p
	_ = this

	localctx = NewSubscriptsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 274, VisualBasic6ParserRULE_subscripts)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2691)
		p.Subscript_()
	}
	p.SetState(2702)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 463, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(2693)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == VisualBasic6ParserWS {
				{
					p.SetState(2692)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2695)
				p.Match(VisualBasic6ParserCOMMA)
			}
			p.SetState(2697)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 462, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(2696)
					p.Match(VisualBasic6ParserWS)
				}

			}
			{
				p.SetState(2699)
				p.Subscript_()
			}

		}
		p.SetState(2704)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 463, p.GetParserRuleContext())
	}

	return localctx
}

// ISubscript_Context is an interface to support dynamic dispatch.
type ISubscript_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubscript_Context differentiates from other interfaces.
	IsSubscript_Context()
}

type Subscript_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubscript_Context() *Subscript_Context {
	var p = new(Subscript_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_subscript_
	return p
}

func (*Subscript_Context) IsSubscript_Context() {}

func NewSubscript_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subscript_Context {
	var p = new(Subscript_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_subscript_

	return p
}

func (s *Subscript_Context) GetParser() antlr.Parser { return s.parser }

func (s *Subscript_Context) AllValueStmt() []IValueStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IValueStmtContext)(nil)).Elem())
	var tst = make([]IValueStmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IValueStmtContext)
		}
	}

	return tst
}

func (s *Subscript_Context) ValueStmt(i int) IValueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IValueStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IValueStmtContext)
}

func (s *Subscript_Context) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *Subscript_Context) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *Subscript_Context) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *Subscript_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Subscript_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Subscript_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterSubscript_(s)
	}
}

func (s *Subscript_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitSubscript_(s)
	}
}

func (p *VisualBasic6Parser) Subscript_() (localctx ISubscript_Context) {
	this := p
	_ = this

	localctx = NewSubscript_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 276, VisualBasic6ParserRULE_subscript_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2710)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 464, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2705)
			p.valueStmt(0)
		}
		{
			p.SetState(2706)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2707)
			p.Match(VisualBasic6ParserTO)
		}
		{
			p.SetState(2708)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2712)
		p.valueStmt(0)
	}

	return localctx
}

// IAmbiguousIdentifierContext is an interface to support dynamic dispatch.
type IAmbiguousIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAmbiguousIdentifierContext differentiates from other interfaces.
	IsAmbiguousIdentifierContext()
}

type AmbiguousIdentifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAmbiguousIdentifierContext() *AmbiguousIdentifierContext {
	var p = new(AmbiguousIdentifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ambiguousIdentifier
	return p
}

func (*AmbiguousIdentifierContext) IsAmbiguousIdentifierContext() {}

func NewAmbiguousIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AmbiguousIdentifierContext {
	var p = new(AmbiguousIdentifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ambiguousIdentifier

	return p
}

func (s *AmbiguousIdentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *AmbiguousIdentifierContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserIDENTIFIER)
}

func (s *AmbiguousIdentifierContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIDENTIFIER, i)
}

func (s *AmbiguousIdentifierContext) AllAmbiguousKeyword() []IAmbiguousKeywordContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAmbiguousKeywordContext)(nil)).Elem())
	var tst = make([]IAmbiguousKeywordContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAmbiguousKeywordContext)
		}
	}

	return tst
}

func (s *AmbiguousIdentifierContext) AmbiguousKeyword(i int) IAmbiguousKeywordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousKeywordContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousKeywordContext)
}

func (s *AmbiguousIdentifierContext) L_SQUARE_BRACKET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserL_SQUARE_BRACKET, 0)
}

func (s *AmbiguousIdentifierContext) R_SQUARE_BRACKET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserR_SQUARE_BRACKET, 0)
}

func (s *AmbiguousIdentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AmbiguousIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AmbiguousIdentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterAmbiguousIdentifier(s)
	}
}

func (s *AmbiguousIdentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitAmbiguousIdentifier(s)
	}
}

func (p *VisualBasic6Parser) AmbiguousIdentifier() (localctx IAmbiguousIdentifierContext) {
	this := p
	_ = this

	localctx = NewAmbiguousIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 278, VisualBasic6ParserRULE_ambiguousIdentifier)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.SetState(2728)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR, VisualBasic6ParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(2716)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
				p.SetState(2716)
				p.GetErrorHandler().Sync(p)

				switch p.GetTokenStream().LA(1) {
				case VisualBasic6ParserIDENTIFIER:
					{
						p.SetState(2714)
						p.Match(VisualBasic6ParserIDENTIFIER)
					}

				case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR:
					{
						p.SetState(2715)
						p.AmbiguousKeyword()
					}

				default:
					panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

			p.SetState(2718)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 466, p.GetParserRuleContext())
		}

	case VisualBasic6ParserL_SQUARE_BRACKET:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2720)
			p.Match(VisualBasic6ParserL_SQUARE_BRACKET)
		}
		p.SetState(2723)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164)))) != 0) || _la == VisualBasic6ParserIDENTIFIER {
			p.SetState(2723)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case VisualBasic6ParserIDENTIFIER:
				{
					p.SetState(2721)
					p.Match(VisualBasic6ParserIDENTIFIER)
				}

			case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR:
				{
					p.SetState(2722)
					p.AmbiguousKeyword()
				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

			p.SetState(2725)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2727)
			p.Match(VisualBasic6ParserR_SQUARE_BRACKET)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IAsTypeClauseContext is an interface to support dynamic dispatch.
type IAsTypeClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAsTypeClauseContext differentiates from other interfaces.
	IsAsTypeClauseContext()
}

type AsTypeClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAsTypeClauseContext() *AsTypeClauseContext {
	var p = new(AsTypeClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_asTypeClause
	return p
}

func (*AsTypeClauseContext) IsAsTypeClauseContext() {}

func NewAsTypeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsTypeClauseContext {
	var p = new(AsTypeClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_asTypeClause

	return p
}

func (s *AsTypeClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *AsTypeClauseContext) AS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAS, 0)
}

func (s *AsTypeClauseContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *AsTypeClauseContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *AsTypeClauseContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *AsTypeClauseContext) NEW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEW, 0)
}

func (s *AsTypeClauseContext) FieldLength() IFieldLengthContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldLengthContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldLengthContext)
}

func (s *AsTypeClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AsTypeClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AsTypeClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterAsTypeClause(s)
	}
}

func (s *AsTypeClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitAsTypeClause(s)
	}
}

func (p *VisualBasic6Parser) AsTypeClause() (localctx IAsTypeClauseContext) {
	this := p
	_ = this

	localctx = NewAsTypeClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 280, VisualBasic6ParserRULE_asTypeClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2730)
		p.Match(VisualBasic6ParserAS)
	}
	{
		p.SetState(2731)
		p.Match(VisualBasic6ParserWS)
	}
	p.SetState(2734)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 470, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2732)
			p.Match(VisualBasic6ParserNEW)
		}
		{
			p.SetState(2733)
			p.Match(VisualBasic6ParserWS)
		}

	}
	{
		p.SetState(2736)
		p.Type_()
	}
	p.SetState(2739)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 471, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2737)
			p.Match(VisualBasic6ParserWS)
		}
		{
			p.SetState(2738)
			p.FieldLength()
		}

	}

	return localctx
}

// IBaseTypeContext is an interface to support dynamic dispatch.
type IBaseTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBaseTypeContext differentiates from other interfaces.
	IsBaseTypeContext()
}

type BaseTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBaseTypeContext() *BaseTypeContext {
	var p = new(BaseTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_baseType
	return p
}

func (*BaseTypeContext) IsBaseTypeContext() {}

func NewBaseTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BaseTypeContext {
	var p = new(BaseTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_baseType

	return p
}

func (s *BaseTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *BaseTypeContext) BOOLEAN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBOOLEAN, 0)
}

func (s *BaseTypeContext) BYTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYTE, 0)
}

func (s *BaseTypeContext) COLLECTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLLECTION, 0)
}

func (s *BaseTypeContext) DATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDATE, 0)
}

func (s *BaseTypeContext) DOUBLE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOUBLE, 0)
}

func (s *BaseTypeContext) INTEGER() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGER, 0)
}

func (s *BaseTypeContext) LONG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLONG, 0)
}

func (s *BaseTypeContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOBJECT, 0)
}

func (s *BaseTypeContext) SINGLE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSINGLE, 0)
}

func (s *BaseTypeContext) STRING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRING, 0)
}

func (s *BaseTypeContext) VARIANT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserVARIANT, 0)
}

func (s *BaseTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BaseTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BaseTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterBaseType(s)
	}
}

func (s *BaseTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitBaseType(s)
	}
}

func (p *VisualBasic6Parser) BaseType() (localctx IBaseTypeContext) {
	this := p
	_ = this

	localctx = NewBaseTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 282, VisualBasic6ParserRULE_baseType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2741)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-13)&-(0x1f+1)) == 0 && ((1<<uint((_la-13)))&((1<<(VisualBasic6ParserBOOLEAN-13))|(1<<(VisualBasic6ParserBYTE-13))|(1<<(VisualBasic6ParserCOLLECTION-13))|(1<<(VisualBasic6ParserDATE-13))|(1<<(VisualBasic6ParserDOUBLE-13)))) != 0) || (((_la-81)&-(0x1f+1)) == 0 && ((1<<uint((_la-81)))&((1<<(VisualBasic6ParserINTEGER-81))|(1<<(VisualBasic6ParserLONG-81))|(1<<(VisualBasic6ParserOBJECT-81)))) != 0) || (((_la-151)&-(0x1f+1)) == 0 && ((1<<uint((_la-151)))&((1<<(VisualBasic6ParserSINGLE-151))|(1<<(VisualBasic6ParserSTRING-151))|(1<<(VisualBasic6ParserVARIANT-151)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// ICertainIdentifierContext is an interface to support dynamic dispatch.
type ICertainIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCertainIdentifierContext differentiates from other interfaces.
	IsCertainIdentifierContext()
}

type CertainIdentifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCertainIdentifierContext() *CertainIdentifierContext {
	var p = new(CertainIdentifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_certainIdentifier
	return p
}

func (*CertainIdentifierContext) IsCertainIdentifierContext() {}

func NewCertainIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CertainIdentifierContext {
	var p = new(CertainIdentifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_certainIdentifier

	return p
}

func (s *CertainIdentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *CertainIdentifierContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserIDENTIFIER)
}

func (s *CertainIdentifierContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIDENTIFIER, i)
}

func (s *CertainIdentifierContext) AllAmbiguousKeyword() []IAmbiguousKeywordContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAmbiguousKeywordContext)(nil)).Elem())
	var tst = make([]IAmbiguousKeywordContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAmbiguousKeywordContext)
		}
	}

	return tst
}

func (s *CertainIdentifierContext) AmbiguousKeyword(i int) IAmbiguousKeywordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousKeywordContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousKeywordContext)
}

func (s *CertainIdentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CertainIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CertainIdentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterCertainIdentifier(s)
	}
}

func (s *CertainIdentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitCertainIdentifier(s)
	}
}

func (p *VisualBasic6Parser) CertainIdentifier() (localctx ICertainIdentifierContext) {
	this := p
	_ = this

	localctx = NewCertainIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 284, VisualBasic6ParserRULE_certainIdentifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.SetState(2758)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2743)
			p.Match(VisualBasic6ParserIDENTIFIER)
		}
		p.SetState(2748)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 473, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(2746)
				p.GetErrorHandler().Sync(p)

				switch p.GetTokenStream().LA(1) {
				case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR:
					{
						p.SetState(2744)
						p.AmbiguousKeyword()
					}

				case VisualBasic6ParserIDENTIFIER:
					{
						p.SetState(2745)
						p.Match(VisualBasic6ParserIDENTIFIER)
					}

				default:
					panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				}

			}
			p.SetState(2750)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 473, p.GetParserRuleContext())
		}

	case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2751)
			p.AmbiguousKeyword()
		}
		p.SetState(2754)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
				p.SetState(2754)
				p.GetErrorHandler().Sync(p)

				switch p.GetTokenStream().LA(1) {
				case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR:
					{
						p.SetState(2752)
						p.AmbiguousKeyword()
					}

				case VisualBasic6ParserIDENTIFIER:
					{
						p.SetState(2753)
						p.Match(VisualBasic6ParserIDENTIFIER)
					}

				default:
					panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

			p.SetState(2756)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 475, p.GetParserRuleContext())
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IComparisonOperatorContext is an interface to support dynamic dispatch.
type IComparisonOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsComparisonOperatorContext differentiates from other interfaces.
	IsComparisonOperatorContext()
}

type ComparisonOperatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext {
	var p = new(ComparisonOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_comparisonOperator
	return p
}

func (*ComparisonOperatorContext) IsComparisonOperatorContext() {}

func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext {
	var p = new(ComparisonOperatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_comparisonOperator

	return p
}

func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser }

func (s *ComparisonOperatorContext) LT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLT, 0)
}

func (s *ComparisonOperatorContext) LEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLEQ, 0)
}

func (s *ComparisonOperatorContext) GT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGT, 0)
}

func (s *ComparisonOperatorContext) GEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGEQ, 0)
}

func (s *ComparisonOperatorContext) EQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQ, 0)
}

func (s *ComparisonOperatorContext) NEQ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEQ, 0)
}

func (s *ComparisonOperatorContext) IS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIS, 0)
}

func (s *ComparisonOperatorContext) LIKE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLIKE, 0)
}

func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterComparisonOperator(s)
	}
}

func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitComparisonOperator(s)
	}
}

func (p *VisualBasic6Parser) ComparisonOperator() (localctx IComparisonOperatorContext) {
	this := p
	_ = this

	localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 286, VisualBasic6ParserRULE_comparisonOperator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2760)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserIS || _la == VisualBasic6ParserLIKE || (((_la-187)&-(0x1f+1)) == 0 && ((1<<uint((_la-187)))&((1<<(VisualBasic6ParserEQ-187))|(1<<(VisualBasic6ParserGEQ-187))|(1<<(VisualBasic6ParserGT-187))|(1<<(VisualBasic6ParserLEQ-187))|(1<<(VisualBasic6ParserLT-187))|(1<<(VisualBasic6ParserNEQ-187)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IComplexTypeContext is an interface to support dynamic dispatch.
type IComplexTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsComplexTypeContext differentiates from other interfaces.
	IsComplexTypeContext()
}

type ComplexTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyComplexTypeContext() *ComplexTypeContext {
	var p = new(ComplexTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_complexType
	return p
}

func (*ComplexTypeContext) IsComplexTypeContext() {}

func NewComplexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComplexTypeContext {
	var p = new(ComplexTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_complexType

	return p
}

func (s *ComplexTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ComplexTypeContext) AllAmbiguousIdentifier() []IAmbiguousIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem())
	var tst = make([]IAmbiguousIdentifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAmbiguousIdentifierContext)
		}
	}

	return tst
}

func (s *ComplexTypeContext) AmbiguousIdentifier(i int) IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *ComplexTypeContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserDOT)
}

func (s *ComplexTypeContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOT, i)
}

func (s *ComplexTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ComplexTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ComplexTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterComplexType(s)
	}
}

func (s *ComplexTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitComplexType(s)
	}
}

func (p *VisualBasic6Parser) ComplexType() (localctx IComplexTypeContext) {
	this := p
	_ = this

	localctx = NewComplexTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 288, VisualBasic6ParserRULE_complexType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2762)
		p.AmbiguousIdentifier()
	}
	p.SetState(2767)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 477, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(2763)
				p.Match(VisualBasic6ParserDOT)
			}
			{
				p.SetState(2764)
				p.AmbiguousIdentifier()
			}

		}
		p.SetState(2769)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 477, p.GetParserRuleContext())
	}

	return localctx
}

// IFieldLengthContext is an interface to support dynamic dispatch.
type IFieldLengthContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldLengthContext differentiates from other interfaces.
	IsFieldLengthContext()
}

type FieldLengthContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldLengthContext() *FieldLengthContext {
	var p = new(FieldLengthContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_fieldLength
	return p
}

func (*FieldLengthContext) IsFieldLengthContext() {}

func NewFieldLengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldLengthContext {
	var p = new(FieldLengthContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_fieldLength

	return p
}

func (s *FieldLengthContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldLengthContext) MULT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMULT, 0)
}

func (s *FieldLengthContext) INTEGERLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGERLITERAL, 0)
}

func (s *FieldLengthContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *FieldLengthContext) WS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, 0)
}

func (s *FieldLengthContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldLengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldLengthContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterFieldLength(s)
	}
}

func (s *FieldLengthContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitFieldLength(s)
	}
}

func (p *VisualBasic6Parser) FieldLength() (localctx IFieldLengthContext) {
	this := p
	_ = this

	localctx = NewFieldLengthContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 290, VisualBasic6ParserRULE_fieldLength)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2770)
		p.Match(VisualBasic6ParserMULT)
	}
	p.SetState(2772)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == VisualBasic6ParserWS {
		{
			p.SetState(2771)
			p.Match(VisualBasic6ParserWS)
		}

	}
	p.SetState(2776)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case VisualBasic6ParserINTEGERLITERAL:
		{
			p.SetState(2774)
			p.Match(VisualBasic6ParserINTEGERLITERAL)
		}

	case VisualBasic6ParserACCESS, VisualBasic6ParserADDRESSOF, VisualBasic6ParserALIAS, VisualBasic6ParserAND, VisualBasic6ParserATTRIBUTE, VisualBasic6ParserAPPACTIVATE, VisualBasic6ParserAPPEND, VisualBasic6ParserAS, VisualBasic6ParserBEEP, VisualBasic6ParserBEGIN, VisualBasic6ParserBINARY, VisualBasic6ParserBOOLEAN, VisualBasic6ParserBYVAL, VisualBasic6ParserBYREF, VisualBasic6ParserBYTE, VisualBasic6ParserCALL, VisualBasic6ParserCASE, VisualBasic6ParserCHDIR, VisualBasic6ParserCHDRIVE, VisualBasic6ParserCLASS, VisualBasic6ParserCLOSE, VisualBasic6ParserCOLLECTION, VisualBasic6ParserCONST, VisualBasic6ParserDATE, VisualBasic6ParserDECLARE, VisualBasic6ParserDEFBOOL, VisualBasic6ParserDEFBYTE, VisualBasic6ParserDEFDATE, VisualBasic6ParserDEFDBL, VisualBasic6ParserDEFDEC, VisualBasic6ParserDEFCUR, VisualBasic6ParserDEFINT, VisualBasic6ParserDEFLNG, VisualBasic6ParserDEFOBJ, VisualBasic6ParserDEFSNG, VisualBasic6ParserDEFSTR, VisualBasic6ParserDEFVAR, VisualBasic6ParserDELETESETTING, VisualBasic6ParserDIM, VisualBasic6ParserDO, VisualBasic6ParserDOUBLE, VisualBasic6ParserEACH, VisualBasic6ParserELSE, VisualBasic6ParserELSEIF, VisualBasic6ParserEND, VisualBasic6ParserENUM, VisualBasic6ParserEQV, VisualBasic6ParserERASE, VisualBasic6ParserERROR, VisualBasic6ParserEVENT, VisualBasic6ParserFALSE, VisualBasic6ParserFILECOPY, VisualBasic6ParserFRIEND, VisualBasic6ParserFOR, VisualBasic6ParserFUNCTION, VisualBasic6ParserGET, VisualBasic6ParserGLOBAL, VisualBasic6ParserGOSUB, VisualBasic6ParserGOTO, VisualBasic6ParserIF, VisualBasic6ParserIMP, VisualBasic6ParserIMPLEMENTS, VisualBasic6ParserIN, VisualBasic6ParserINPUT, VisualBasic6ParserIS, VisualBasic6ParserINTEGER, VisualBasic6ParserKILL, VisualBasic6ParserLOAD, VisualBasic6ParserLOCK, VisualBasic6ParserLONG, VisualBasic6ParserLOOP, VisualBasic6ParserLEN, VisualBasic6ParserLET, VisualBasic6ParserLIB, VisualBasic6ParserLIKE, VisualBasic6ParserLSET, VisualBasic6ParserME, VisualBasic6ParserMID, VisualBasic6ParserMKDIR, VisualBasic6ParserMOD, VisualBasic6ParserNAME, VisualBasic6ParserNEXT, VisualBasic6ParserNEW, VisualBasic6ParserNOT, VisualBasic6ParserNOTHING, VisualBasic6ParserNULL_, VisualBasic6ParserOBJECT, VisualBasic6ParserON, VisualBasic6ParserOPEN, VisualBasic6ParserOPTIONAL, VisualBasic6ParserOR, VisualBasic6ParserOUTPUT, VisualBasic6ParserPARAMARRAY, VisualBasic6ParserPRESERVE, VisualBasic6ParserPRINT, VisualBasic6ParserPRIVATE, VisualBasic6ParserPUBLIC, VisualBasic6ParserPUT, VisualBasic6ParserRANDOM, VisualBasic6ParserRANDOMIZE, VisualBasic6ParserRAISEEVENT, VisualBasic6ParserREAD, VisualBasic6ParserREDIM, VisualBasic6ParserREM, VisualBasic6ParserRESET, VisualBasic6ParserRESUME, VisualBasic6ParserRETURN, VisualBasic6ParserRMDIR, VisualBasic6ParserRSET, VisualBasic6ParserSAVEPICTURE, VisualBasic6ParserSAVESETTING, VisualBasic6ParserSEEK, VisualBasic6ParserSELECT, VisualBasic6ParserSENDKEYS, VisualBasic6ParserSET, VisualBasic6ParserSETATTR, VisualBasic6ParserSHARED, VisualBasic6ParserSINGLE, VisualBasic6ParserSPC, VisualBasic6ParserSTATIC, VisualBasic6ParserSTEP, VisualBasic6ParserSTOP, VisualBasic6ParserSTRING, VisualBasic6ParserSUB, VisualBasic6ParserTAB, VisualBasic6ParserTEXT, VisualBasic6ParserTHEN, VisualBasic6ParserTIME, VisualBasic6ParserTO, VisualBasic6ParserTRUE, VisualBasic6ParserTYPE, VisualBasic6ParserTYPEOF, VisualBasic6ParserUNLOAD, VisualBasic6ParserUNLOCK, VisualBasic6ParserUNTIL, VisualBasic6ParserVARIANT, VisualBasic6ParserVERSION, VisualBasic6ParserWEND, VisualBasic6ParserWHILE, VisualBasic6ParserWIDTH, VisualBasic6ParserWITH, VisualBasic6ParserWITHEVENTS, VisualBasic6ParserWRITE, VisualBasic6ParserXOR, VisualBasic6ParserL_SQUARE_BRACKET, VisualBasic6ParserIDENTIFIER:
		{
			p.SetState(2775)
			p.AmbiguousIdentifier()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ILetterrangeContext is an interface to support dynamic dispatch.
type ILetterrangeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLetterrangeContext differentiates from other interfaces.
	IsLetterrangeContext()
}

type LetterrangeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLetterrangeContext() *LetterrangeContext {
	var p = new(LetterrangeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_letterrange
	return p
}

func (*LetterrangeContext) IsLetterrangeContext() {}

func NewLetterrangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LetterrangeContext {
	var p = new(LetterrangeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_letterrange

	return p
}

func (s *LetterrangeContext) GetParser() antlr.Parser { return s.parser }

func (s *LetterrangeContext) AllCertainIdentifier() []ICertainIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICertainIdentifierContext)(nil)).Elem())
	var tst = make([]ICertainIdentifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICertainIdentifierContext)
		}
	}

	return tst
}

func (s *LetterrangeContext) CertainIdentifier(i int) ICertainIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICertainIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICertainIdentifierContext)
}

func (s *LetterrangeContext) MINUS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMINUS, 0)
}

func (s *LetterrangeContext) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *LetterrangeContext) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *LetterrangeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LetterrangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LetterrangeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLetterrange(s)
	}
}

func (s *LetterrangeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLetterrange(s)
	}
}

func (p *VisualBasic6Parser) Letterrange() (localctx ILetterrangeContext) {
	this := p
	_ = this

	localctx = NewLetterrangeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 292, VisualBasic6ParserRULE_letterrange)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2778)
		p.CertainIdentifier()
	}
	p.SetState(2787)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 {
		p.SetState(2780)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2779)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2782)
			p.Match(VisualBasic6ParserMINUS)
		}
		p.SetState(2784)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2783)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2786)
			p.CertainIdentifier()
		}

	}

	return localctx
}

// ILineLabelContext is an interface to support dynamic dispatch.
type ILineLabelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLineLabelContext differentiates from other interfaces.
	IsLineLabelContext()
}

type LineLabelContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLineLabelContext() *LineLabelContext {
	var p = new(LineLabelContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_lineLabel
	return p
}

func (*LineLabelContext) IsLineLabelContext() {}

func NewLineLabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LineLabelContext {
	var p = new(LineLabelContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_lineLabel

	return p
}

func (s *LineLabelContext) GetParser() antlr.Parser { return s.parser }

func (s *LineLabelContext) AmbiguousIdentifier() IAmbiguousIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousIdentifierContext)
}

func (s *LineLabelContext) COLON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLON, 0)
}

func (s *LineLabelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LineLabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LineLabelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLineLabel(s)
	}
}

func (s *LineLabelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLineLabel(s)
	}
}

func (p *VisualBasic6Parser) LineLabel() (localctx ILineLabelContext) {
	this := p
	_ = this

	localctx = NewLineLabelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 294, VisualBasic6ParserRULE_lineLabel)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2789)
		p.AmbiguousIdentifier()
	}
	{
		p.SetState(2790)
		p.Match(VisualBasic6ParserCOLON)
	}

	return localctx
}

// ILiteralContext is an interface to support dynamic dispatch.
type ILiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLiteralContext differentiates from other interfaces.
	IsLiteralContext()
}

type LiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLiteralContext() *LiteralContext {
	var p = new(LiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_literal
	return p
}

func (*LiteralContext) IsLiteralContext() {}

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext {
	var p = new(LiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_literal

	return p
}

func (s *LiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *LiteralContext) COLORLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLORLITERAL, 0)
}

func (s *LiteralContext) DATELITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDATELITERAL, 0)
}

func (s *LiteralContext) DOUBLELITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOUBLELITERAL, 0)
}

func (s *LiteralContext) FILENUMBER() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFILENUMBER, 0)
}

func (s *LiteralContext) INTEGERLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGERLITERAL, 0)
}

func (s *LiteralContext) OCTALLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOCTALLITERAL, 0)
}

func (s *LiteralContext) STRINGLITERAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRINGLITERAL, 0)
}

func (s *LiteralContext) TRUE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTRUE, 0)
}

func (s *LiteralContext) FALSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFALSE, 0)
}

func (s *LiteralContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNOTHING, 0)
}

func (s *LiteralContext) NULL_() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNULL_, 0)
}

func (s *LiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterLiteral(s)
	}
}

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitLiteral(s)
	}
}

func (p *VisualBasic6Parser) Literal() (localctx ILiteralContext) {
	this := p
	_ = this

	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 296, VisualBasic6ParserRULE_literal)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2792)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserFALSE || _la == VisualBasic6ParserNOTHING || _la == VisualBasic6ParserNULL_ || _la == VisualBasic6ParserTRUE || (((_la-209)&-(0x1f+1)) == 0 && ((1<<uint((_la-209)))&((1<<(VisualBasic6ParserSTRINGLITERAL-209))|(1<<(VisualBasic6ParserDATELITERAL-209))|(1<<(VisualBasic6ParserCOLORLITERAL-209))|(1<<(VisualBasic6ParserINTEGERLITERAL-209))|(1<<(VisualBasic6ParserDOUBLELITERAL-209))|(1<<(VisualBasic6ParserFILENUMBER-209))|(1<<(VisualBasic6ParserOCTALLITERAL-209)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IPublicPrivateVisibilityContext is an interface to support dynamic dispatch.
type IPublicPrivateVisibilityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPublicPrivateVisibilityContext differentiates from other interfaces.
	IsPublicPrivateVisibilityContext()
}

type PublicPrivateVisibilityContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPublicPrivateVisibilityContext() *PublicPrivateVisibilityContext {
	var p = new(PublicPrivateVisibilityContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_publicPrivateVisibility
	return p
}

func (*PublicPrivateVisibilityContext) IsPublicPrivateVisibilityContext() {}

func NewPublicPrivateVisibilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PublicPrivateVisibilityContext {
	var p = new(PublicPrivateVisibilityContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_publicPrivateVisibility

	return p
}

func (s *PublicPrivateVisibilityContext) GetParser() antlr.Parser { return s.parser }

func (s *PublicPrivateVisibilityContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRIVATE, 0)
}

func (s *PublicPrivateVisibilityContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUBLIC, 0)
}

func (s *PublicPrivateVisibilityContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PublicPrivateVisibilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PublicPrivateVisibilityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPublicPrivateVisibility(s)
	}
}

func (s *PublicPrivateVisibilityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPublicPrivateVisibility(s)
	}
}

func (p *VisualBasic6Parser) PublicPrivateVisibility() (localctx IPublicPrivateVisibilityContext) {
	this := p
	_ = this

	localctx = NewPublicPrivateVisibilityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 298, VisualBasic6ParserRULE_publicPrivateVisibility)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2794)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IPublicPrivateGlobalVisibilityContext is an interface to support dynamic dispatch.
type IPublicPrivateGlobalVisibilityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPublicPrivateGlobalVisibilityContext differentiates from other interfaces.
	IsPublicPrivateGlobalVisibilityContext()
}

type PublicPrivateGlobalVisibilityContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPublicPrivateGlobalVisibilityContext() *PublicPrivateGlobalVisibilityContext {
	var p = new(PublicPrivateGlobalVisibilityContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_publicPrivateGlobalVisibility
	return p
}

func (*PublicPrivateGlobalVisibilityContext) IsPublicPrivateGlobalVisibilityContext() {}

func NewPublicPrivateGlobalVisibilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PublicPrivateGlobalVisibilityContext {
	var p = new(PublicPrivateGlobalVisibilityContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_publicPrivateGlobalVisibility

	return p
}

func (s *PublicPrivateGlobalVisibilityContext) GetParser() antlr.Parser { return s.parser }

func (s *PublicPrivateGlobalVisibilityContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRIVATE, 0)
}

func (s *PublicPrivateGlobalVisibilityContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUBLIC, 0)
}

func (s *PublicPrivateGlobalVisibilityContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGLOBAL, 0)
}

func (s *PublicPrivateGlobalVisibilityContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PublicPrivateGlobalVisibilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PublicPrivateGlobalVisibilityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterPublicPrivateGlobalVisibility(s)
	}
}

func (s *PublicPrivateGlobalVisibilityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitPublicPrivateGlobalVisibility(s)
	}
}

func (p *VisualBasic6Parser) PublicPrivateGlobalVisibility() (localctx IPublicPrivateGlobalVisibilityContext) {
	this := p
	_ = this

	localctx = NewPublicPrivateGlobalVisibilityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 300, VisualBasic6ParserRULE_publicPrivateGlobalVisibility)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2796)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IType_Context is an interface to support dynamic dispatch.
type IType_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsType_Context differentiates from other interfaces.
	IsType_Context()
}

type Type_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_Context() *Type_Context {
	var p = new(Type_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_type_
	return p
}

func (*Type_Context) IsType_Context() {}

func NewType_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_Context {
	var p = new(Type_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_type_

	return p
}

func (s *Type_Context) GetParser() antlr.Parser { return s.parser }

func (s *Type_Context) BaseType() IBaseTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBaseTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBaseTypeContext)
}

func (s *Type_Context) ComplexType() IComplexTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComplexTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComplexTypeContext)
}

func (s *Type_Context) LPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLPAREN, 0)
}

func (s *Type_Context) RPAREN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRPAREN, 0)
}

func (s *Type_Context) AllWS() []antlr.TerminalNode {
	return s.GetTokens(VisualBasic6ParserWS)
}

func (s *Type_Context) WS(i int) antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWS, i)
}

func (s *Type_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterType_(s)
	}
}

func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitType_(s)
	}
}

func (p *VisualBasic6Parser) Type_() (localctx IType_Context) {
	this := p
	_ = this

	localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 302, VisualBasic6ParserRULE_type_)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2800)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 483, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2798)
			p.BaseType()
		}

	case 2:
		{
			p.SetState(2799)
			p.ComplexType()
		}

	}
	p.SetState(2810)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 486, p.GetParserRuleContext()) == 1 {
		p.SetState(2803)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2802)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2805)
			p.Match(VisualBasic6ParserLPAREN)
		}
		p.SetState(2807)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == VisualBasic6ParserWS {
			{
				p.SetState(2806)
				p.Match(VisualBasic6ParserWS)
			}

		}
		{
			p.SetState(2809)
			p.Match(VisualBasic6ParserRPAREN)
		}

	}

	return localctx
}

// ITypeHintContext is an interface to support dynamic dispatch.
type ITypeHintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeHintContext differentiates from other interfaces.
	IsTypeHintContext()
}

type TypeHintContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeHintContext() *TypeHintContext {
	var p = new(TypeHintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_typeHint
	return p
}

func (*TypeHintContext) IsTypeHintContext() {}

func NewTypeHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeHintContext {
	var p = new(TypeHintContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_typeHint

	return p
}

func (s *TypeHintContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeHintContext) AMPERSAND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAMPERSAND, 0)
}

func (s *TypeHintContext) AT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAT, 0)
}

func (s *TypeHintContext) DOLLAR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOLLAR, 0)
}

func (s *TypeHintContext) EXCLAMATIONMARK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEXCLAMATIONMARK, 0)
}

func (s *TypeHintContext) HASH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserHASH, 0)
}

func (s *TypeHintContext) PERCENT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPERCENT, 0)
}

func (s *TypeHintContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeHintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterTypeHint(s)
	}
}

func (s *TypeHintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitTypeHint(s)
	}
}

func (p *VisualBasic6Parser) TypeHint() (localctx ITypeHintContext) {
	this := p
	_ = this

	localctx = NewTypeHintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 304, VisualBasic6ParserRULE_typeHint)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2812)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-178)&-(0x1f+1)) == 0 && ((1<<uint((_la-178)))&((1<<(VisualBasic6ParserAMPERSAND-178))|(1<<(VisualBasic6ParserAT-178))|(1<<(VisualBasic6ParserDOLLAR-178))|(1<<(VisualBasic6ParserEXCLAMATIONMARK-178))|(1<<(VisualBasic6ParserHASH-178))|(1<<(VisualBasic6ParserPERCENT-178)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IVisibilityContext is an interface to support dynamic dispatch.
type IVisibilityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVisibilityContext differentiates from other interfaces.
	IsVisibilityContext()
}

type VisibilityContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVisibilityContext() *VisibilityContext {
	var p = new(VisibilityContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_visibility
	return p
}

func (*VisibilityContext) IsVisibilityContext() {}

func NewVisibilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VisibilityContext {
	var p = new(VisibilityContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_visibility

	return p
}

func (s *VisibilityContext) GetParser() antlr.Parser { return s.parser }

func (s *VisibilityContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRIVATE, 0)
}

func (s *VisibilityContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUBLIC, 0)
}

func (s *VisibilityContext) FRIEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFRIEND, 0)
}

func (s *VisibilityContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGLOBAL, 0)
}

func (s *VisibilityContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VisibilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VisibilityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterVisibility(s)
	}
}

func (s *VisibilityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitVisibility(s)
	}
}

func (p *VisualBasic6Parser) Visibility() (localctx IVisibilityContext) {
	this := p
	_ = this

	localctx = NewVisibilityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 306, VisualBasic6ParserRULE_visibility)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2814)
		_la = p.GetTokenStream().LA(1)

		if !(_la == VisualBasic6ParserFRIEND || _la == VisualBasic6ParserGLOBAL || _la == VisualBasic6ParserPRIVATE || _la == VisualBasic6ParserPUBLIC) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IAmbiguousKeywordContext is an interface to support dynamic dispatch.
type IAmbiguousKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAmbiguousKeywordContext differentiates from other interfaces.
	IsAmbiguousKeywordContext()
}

type AmbiguousKeywordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAmbiguousKeywordContext() *AmbiguousKeywordContext {
	var p = new(AmbiguousKeywordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = VisualBasic6ParserRULE_ambiguousKeyword
	return p
}

func (*AmbiguousKeywordContext) IsAmbiguousKeywordContext() {}

func NewAmbiguousKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AmbiguousKeywordContext {
	var p = new(AmbiguousKeywordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = VisualBasic6ParserRULE_ambiguousKeyword

	return p
}

func (s *AmbiguousKeywordContext) GetParser() antlr.Parser { return s.parser }

func (s *AmbiguousKeywordContext) ACCESS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserACCESS, 0)
}

func (s *AmbiguousKeywordContext) ADDRESSOF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserADDRESSOF, 0)
}

func (s *AmbiguousKeywordContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserALIAS, 0)
}

func (s *AmbiguousKeywordContext) AND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAND, 0)
}

func (s *AmbiguousKeywordContext) ATTRIBUTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserATTRIBUTE, 0)
}

func (s *AmbiguousKeywordContext) APPACTIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAPPACTIVATE, 0)
}

func (s *AmbiguousKeywordContext) APPEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAPPEND, 0)
}

func (s *AmbiguousKeywordContext) AS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserAS, 0)
}

func (s *AmbiguousKeywordContext) BEEP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEEP, 0)
}

func (s *AmbiguousKeywordContext) BEGIN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBEGIN, 0)
}

func (s *AmbiguousKeywordContext) BINARY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBINARY, 0)
}

func (s *AmbiguousKeywordContext) BOOLEAN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBOOLEAN, 0)
}

func (s *AmbiguousKeywordContext) BYVAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYVAL, 0)
}

func (s *AmbiguousKeywordContext) BYREF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYREF, 0)
}

func (s *AmbiguousKeywordContext) BYTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserBYTE, 0)
}

func (s *AmbiguousKeywordContext) CALL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCALL, 0)
}

func (s *AmbiguousKeywordContext) CASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCASE, 0)
}

func (s *AmbiguousKeywordContext) CLASS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCLASS, 0)
}

func (s *AmbiguousKeywordContext) CLOSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCLOSE, 0)
}

func (s *AmbiguousKeywordContext) CHDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCHDIR, 0)
}

func (s *AmbiguousKeywordContext) CHDRIVE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCHDRIVE, 0)
}

func (s *AmbiguousKeywordContext) COLLECTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCOLLECTION, 0)
}

func (s *AmbiguousKeywordContext) CONST() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserCONST, 0)
}

func (s *AmbiguousKeywordContext) DATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDATE, 0)
}

func (s *AmbiguousKeywordContext) DECLARE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDECLARE, 0)
}

func (s *AmbiguousKeywordContext) DEFBOOL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFBOOL, 0)
}

func (s *AmbiguousKeywordContext) DEFBYTE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFBYTE, 0)
}

func (s *AmbiguousKeywordContext) DEFCUR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFCUR, 0)
}

func (s *AmbiguousKeywordContext) DEFDBL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDBL, 0)
}

func (s *AmbiguousKeywordContext) DEFDATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDATE, 0)
}

func (s *AmbiguousKeywordContext) DEFDEC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFDEC, 0)
}

func (s *AmbiguousKeywordContext) DEFINT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFINT, 0)
}

func (s *AmbiguousKeywordContext) DEFLNG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFLNG, 0)
}

func (s *AmbiguousKeywordContext) DEFOBJ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFOBJ, 0)
}

func (s *AmbiguousKeywordContext) DEFSNG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFSNG, 0)
}

func (s *AmbiguousKeywordContext) DEFSTR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFSTR, 0)
}

func (s *AmbiguousKeywordContext) DEFVAR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDEFVAR, 0)
}

func (s *AmbiguousKeywordContext) DELETESETTING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDELETESETTING, 0)
}

func (s *AmbiguousKeywordContext) DIM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDIM, 0)
}

func (s *AmbiguousKeywordContext) DO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDO, 0)
}

func (s *AmbiguousKeywordContext) DOUBLE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserDOUBLE, 0)
}

func (s *AmbiguousKeywordContext) EACH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEACH, 0)
}

func (s *AmbiguousKeywordContext) ELSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSE, 0)
}

func (s *AmbiguousKeywordContext) ELSEIF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserELSEIF, 0)
}

func (s *AmbiguousKeywordContext) END() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEND, 0)
}

func (s *AmbiguousKeywordContext) ENUM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserENUM, 0)
}

func (s *AmbiguousKeywordContext) EQV() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEQV, 0)
}

func (s *AmbiguousKeywordContext) ERASE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserERASE, 0)
}

func (s *AmbiguousKeywordContext) ERROR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserERROR, 0)
}

func (s *AmbiguousKeywordContext) EVENT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserEVENT, 0)
}

func (s *AmbiguousKeywordContext) FALSE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFALSE, 0)
}

func (s *AmbiguousKeywordContext) FILECOPY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFILECOPY, 0)
}

func (s *AmbiguousKeywordContext) FRIEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFRIEND, 0)
}

func (s *AmbiguousKeywordContext) FOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFOR, 0)
}

func (s *AmbiguousKeywordContext) FUNCTION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserFUNCTION, 0)
}

func (s *AmbiguousKeywordContext) GET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGET, 0)
}

func (s *AmbiguousKeywordContext) GLOBAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGLOBAL, 0)
}

func (s *AmbiguousKeywordContext) GOSUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOSUB, 0)
}

func (s *AmbiguousKeywordContext) GOTO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserGOTO, 0)
}

func (s *AmbiguousKeywordContext) IF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIF, 0)
}

func (s *AmbiguousKeywordContext) IMP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIMP, 0)
}

func (s *AmbiguousKeywordContext) IMPLEMENTS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIMPLEMENTS, 0)
}

func (s *AmbiguousKeywordContext) IN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIN, 0)
}

func (s *AmbiguousKeywordContext) INPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINPUT, 0)
}

func (s *AmbiguousKeywordContext) IS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserIS, 0)
}

func (s *AmbiguousKeywordContext) INTEGER() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserINTEGER, 0)
}

func (s *AmbiguousKeywordContext) KILL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserKILL, 0)
}

func (s *AmbiguousKeywordContext) LOAD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOAD, 0)
}

func (s *AmbiguousKeywordContext) LOCK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOCK, 0)
}

func (s *AmbiguousKeywordContext) LONG() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLONG, 0)
}

func (s *AmbiguousKeywordContext) LOOP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLOOP, 0)
}

func (s *AmbiguousKeywordContext) LEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLEN, 0)
}

func (s *AmbiguousKeywordContext) LET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLET, 0)
}

func (s *AmbiguousKeywordContext) LIB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLIB, 0)
}

func (s *AmbiguousKeywordContext) LIKE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLIKE, 0)
}

func (s *AmbiguousKeywordContext) LSET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserLSET, 0)
}

func (s *AmbiguousKeywordContext) ME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserME, 0)
}

func (s *AmbiguousKeywordContext) MID() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMID, 0)
}

func (s *AmbiguousKeywordContext) MKDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMKDIR, 0)
}

func (s *AmbiguousKeywordContext) MOD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserMOD, 0)
}

func (s *AmbiguousKeywordContext) NAME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNAME, 0)
}

func (s *AmbiguousKeywordContext) NEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEXT, 0)
}

func (s *AmbiguousKeywordContext) NEW() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNEW, 0)
}

func (s *AmbiguousKeywordContext) NOT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNOT, 0)
}

func (s *AmbiguousKeywordContext) NOTHING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNOTHING, 0)
}

func (s *AmbiguousKeywordContext) NULL_() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserNULL_, 0)
}

func (s *AmbiguousKeywordContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOBJECT, 0)
}

func (s *AmbiguousKeywordContext) ON() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserON, 0)
}

func (s *AmbiguousKeywordContext) OPEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPEN, 0)
}

func (s *AmbiguousKeywordContext) OPTIONAL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOPTIONAL, 0)
}

func (s *AmbiguousKeywordContext) OR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOR, 0)
}

func (s *AmbiguousKeywordContext) OUTPUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserOUTPUT, 0)
}

func (s *AmbiguousKeywordContext) PARAMARRAY() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPARAMARRAY, 0)
}

func (s *AmbiguousKeywordContext) PRESERVE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRESERVE, 0)
}

func (s *AmbiguousKeywordContext) PRINT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRINT, 0)
}

func (s *AmbiguousKeywordContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPRIVATE, 0)
}

func (s *AmbiguousKeywordContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUBLIC, 0)
}

func (s *AmbiguousKeywordContext) PUT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserPUT, 0)
}

func (s *AmbiguousKeywordContext) RANDOM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRANDOM, 0)
}

func (s *AmbiguousKeywordContext) RANDOMIZE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRANDOMIZE, 0)
}

func (s *AmbiguousKeywordContext) RAISEEVENT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRAISEEVENT, 0)
}

func (s *AmbiguousKeywordContext) READ() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREAD, 0)
}

func (s *AmbiguousKeywordContext) REDIM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREDIM, 0)
}

func (s *AmbiguousKeywordContext) REM() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserREM, 0)
}

func (s *AmbiguousKeywordContext) RESET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRESET, 0)
}

func (s *AmbiguousKeywordContext) RESUME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRESUME, 0)
}

func (s *AmbiguousKeywordContext) RETURN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRETURN, 0)
}

func (s *AmbiguousKeywordContext) RMDIR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRMDIR, 0)
}

func (s *AmbiguousKeywordContext) RSET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserRSET, 0)
}

func (s *AmbiguousKeywordContext) SAVEPICTURE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSAVEPICTURE, 0)
}

func (s *AmbiguousKeywordContext) SAVESETTING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSAVESETTING, 0)
}

func (s *AmbiguousKeywordContext) SEEK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSEEK, 0)
}

func (s *AmbiguousKeywordContext) SELECT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSELECT, 0)
}

func (s *AmbiguousKeywordContext) SENDKEYS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSENDKEYS, 0)
}

func (s *AmbiguousKeywordContext) SET() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSET, 0)
}

func (s *AmbiguousKeywordContext) SETATTR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSETATTR, 0)
}

func (s *AmbiguousKeywordContext) SHARED() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSHARED, 0)
}

func (s *AmbiguousKeywordContext) SINGLE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSINGLE, 0)
}

func (s *AmbiguousKeywordContext) SPC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSPC, 0)
}

func (s *AmbiguousKeywordContext) STATIC() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTATIC, 0)
}

func (s *AmbiguousKeywordContext) STEP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTEP, 0)
}

func (s *AmbiguousKeywordContext) STOP() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTOP, 0)
}

func (s *AmbiguousKeywordContext) STRING() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSTRING, 0)
}

func (s *AmbiguousKeywordContext) SUB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserSUB, 0)
}

func (s *AmbiguousKeywordContext) TAB() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTAB, 0)
}

func (s *AmbiguousKeywordContext) TEXT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTEXT, 0)
}

func (s *AmbiguousKeywordContext) THEN() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTHEN, 0)
}

func (s *AmbiguousKeywordContext) TIME() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTIME, 0)
}

func (s *AmbiguousKeywordContext) TO() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTO, 0)
}

func (s *AmbiguousKeywordContext) TRUE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTRUE, 0)
}

func (s *AmbiguousKeywordContext) TYPE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTYPE, 0)
}

func (s *AmbiguousKeywordContext) TYPEOF() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserTYPEOF, 0)
}

func (s *AmbiguousKeywordContext) UNLOAD() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNLOAD, 0)
}

func (s *AmbiguousKeywordContext) UNLOCK() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNLOCK, 0)
}

func (s *AmbiguousKeywordContext) UNTIL() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserUNTIL, 0)
}

func (s *AmbiguousKeywordContext) VARIANT() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserVARIANT, 0)
}

func (s *AmbiguousKeywordContext) VERSION() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserVERSION, 0)
}

func (s *AmbiguousKeywordContext) WEND() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWEND, 0)
}

func (s *AmbiguousKeywordContext) WHILE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWHILE, 0)
}

func (s *AmbiguousKeywordContext) WIDTH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWIDTH, 0)
}

func (s *AmbiguousKeywordContext) WITH() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWITH, 0)
}

func (s *AmbiguousKeywordContext) WITHEVENTS() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWITHEVENTS, 0)
}

func (s *AmbiguousKeywordContext) WRITE() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserWRITE, 0)
}

func (s *AmbiguousKeywordContext) XOR() antlr.TerminalNode {
	return s.GetToken(VisualBasic6ParserXOR, 0)
}

func (s *AmbiguousKeywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AmbiguousKeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AmbiguousKeywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.EnterAmbiguousKeyword(s)
	}
}

func (s *AmbiguousKeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(VisualBasic6ParserListener); ok {
		listenerT.ExitAmbiguousKeyword(s)
	}
}

func (p *VisualBasic6Parser) AmbiguousKeyword() (localctx IAmbiguousKeywordContext) {
	this := p
	_ = this

	localctx = NewAmbiguousKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 308, VisualBasic6ParserRULE_ambiguousKeyword)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2816)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<VisualBasic6ParserACCESS)|(1<<VisualBasic6ParserADDRESSOF)|(1<<VisualBasic6ParserALIAS)|(1<<VisualBasic6ParserAND)|(1<<VisualBasic6ParserATTRIBUTE)|(1<<VisualBasic6ParserAPPACTIVATE)|(1<<VisualBasic6ParserAPPEND)|(1<<VisualBasic6ParserAS)|(1<<VisualBasic6ParserBEEP)|(1<<VisualBasic6ParserBEGIN)|(1<<VisualBasic6ParserBINARY)|(1<<VisualBasic6ParserBOOLEAN)|(1<<VisualBasic6ParserBYVAL)|(1<<VisualBasic6ParserBYREF)|(1<<VisualBasic6ParserBYTE)|(1<<VisualBasic6ParserCALL)|(1<<VisualBasic6ParserCASE)|(1<<VisualBasic6ParserCHDIR)|(1<<VisualBasic6ParserCHDRIVE)|(1<<VisualBasic6ParserCLASS)|(1<<VisualBasic6ParserCLOSE)|(1<<VisualBasic6ParserCOLLECTION)|(1<<VisualBasic6ParserCONST)|(1<<VisualBasic6ParserDATE)|(1<<VisualBasic6ParserDECLARE)|(1<<VisualBasic6ParserDEFBOOL)|(1<<VisualBasic6ParserDEFBYTE)|(1<<VisualBasic6ParserDEFDATE)|(1<<VisualBasic6ParserDEFDBL)|(1<<VisualBasic6ParserDEFDEC))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(VisualBasic6ParserDEFCUR-32))|(1<<(VisualBasic6ParserDEFINT-32))|(1<<(VisualBasic6ParserDEFLNG-32))|(1<<(VisualBasic6ParserDEFOBJ-32))|(1<<(VisualBasic6ParserDEFSNG-32))|(1<<(VisualBasic6ParserDEFSTR-32))|(1<<(VisualBasic6ParserDEFVAR-32))|(1<<(VisualBasic6ParserDELETESETTING-32))|(1<<(VisualBasic6ParserDIM-32))|(1<<(VisualBasic6ParserDO-32))|(1<<(VisualBasic6ParserDOUBLE-32))|(1<<(VisualBasic6ParserEACH-32))|(1<<(VisualBasic6ParserELSE-32))|(1<<(VisualBasic6ParserELSEIF-32))|(1<<(VisualBasic6ParserEND-32))|(1<<(VisualBasic6ParserENUM-32))|(1<<(VisualBasic6ParserEQV-32))|(1<<(VisualBasic6ParserERASE-32))|(1<<(VisualBasic6ParserERROR-32))|(1<<(VisualBasic6ParserEVENT-32)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(VisualBasic6ParserFALSE-66))|(1<<(VisualBasic6ParserFILECOPY-66))|(1<<(VisualBasic6ParserFRIEND-66))|(1<<(VisualBasic6ParserFOR-66))|(1<<(VisualBasic6ParserFUNCTION-66))|(1<<(VisualBasic6ParserGET-66))|(1<<(VisualBasic6ParserGLOBAL-66))|(1<<(VisualBasic6ParserGOSUB-66))|(1<<(VisualBasic6ParserGOTO-66))|(1<<(VisualBasic6ParserIF-66))|(1<<(VisualBasic6ParserIMP-66))|(1<<(VisualBasic6ParserIMPLEMENTS-66))|(1<<(VisualBasic6ParserIN-66))|(1<<(VisualBasic6ParserINPUT-66))|(1<<(VisualBasic6ParserIS-66))|(1<<(VisualBasic6ParserINTEGER-66))|(1<<(VisualBasic6ParserKILL-66))|(1<<(VisualBasic6ParserLOAD-66))|(1<<(VisualBasic6ParserLOCK-66))|(1<<(VisualBasic6ParserLONG-66))|(1<<(VisualBasic6ParserLOOP-66))|(1<<(VisualBasic6ParserLEN-66))|(1<<(VisualBasic6ParserLET-66))|(1<<(VisualBasic6ParserLIB-66))|(1<<(VisualBasic6ParserLIKE-66))|(1<<(VisualBasic6ParserLSET-66)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(VisualBasic6ParserME-100))|(1<<(VisualBasic6ParserMID-100))|(1<<(VisualBasic6ParserMKDIR-100))|(1<<(VisualBasic6ParserMOD-100))|(1<<(VisualBasic6ParserNAME-100))|(1<<(VisualBasic6ParserNEXT-100))|(1<<(VisualBasic6ParserNEW-100))|(1<<(VisualBasic6ParserNOT-100))|(1<<(VisualBasic6ParserNOTHING-100))|(1<<(VisualBasic6ParserNULL_-100))|(1<<(VisualBasic6ParserOBJECT-100))|(1<<(VisualBasic6ParserON-100))|(1<<(VisualBasic6ParserOPEN-100))|(1<<(VisualBasic6ParserOPTIONAL-100))|(1<<(VisualBasic6ParserOR-100))|(1<<(VisualBasic6ParserOUTPUT-100))|(1<<(VisualBasic6ParserPARAMARRAY-100))|(1<<(VisualBasic6ParserPRESERVE-100))|(1<<(VisualBasic6ParserPRINT-100))|(1<<(VisualBasic6ParserPRIVATE-100))|(1<<(VisualBasic6ParserPUBLIC-100))|(1<<(VisualBasic6ParserPUT-100))|(1<<(VisualBasic6ParserRANDOM-100)))) != 0) || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(VisualBasic6ParserRANDOMIZE-132))|(1<<(VisualBasic6ParserRAISEEVENT-132))|(1<<(VisualBasic6ParserREAD-132))|(1<<(VisualBasic6ParserREDIM-132))|(1<<(VisualBasic6ParserREM-132))|(1<<(VisualBasic6ParserRESET-132))|(1<<(VisualBasic6ParserRESUME-132))|(1<<(VisualBasic6ParserRETURN-132))|(1<<(VisualBasic6ParserRMDIR-132))|(1<<(VisualBasic6ParserRSET-132))|(1<<(VisualBasic6ParserSAVEPICTURE-132))|(1<<(VisualBasic6ParserSAVESETTING-132))|(1<<(VisualBasic6ParserSEEK-132))|(1<<(VisualBasic6ParserSELECT-132))|(1<<(VisualBasic6ParserSENDKEYS-132))|(1<<(VisualBasic6ParserSET-132))|(1<<(VisualBasic6ParserSETATTR-132))|(1<<(VisualBasic6ParserSHARED-132))|(1<<(VisualBasic6ParserSINGLE-132))|(1<<(VisualBasic6ParserSPC-132))|(1<<(VisualBasic6ParserSTATIC-132))|(1<<(VisualBasic6ParserSTEP-132))|(1<<(VisualBasic6ParserSTOP-132))|(1<<(VisualBasic6ParserSTRING-132))|(1<<(VisualBasic6ParserSUB-132))|(1<<(VisualBasic6ParserTAB-132))|(1<<(VisualBasic6ParserTEXT-132))|(1<<(VisualBasic6ParserTHEN-132))|(1<<(VisualBasic6ParserTIME-132))|(1<<(VisualBasic6ParserTO-132))|(1<<(VisualBasic6ParserTRUE-132)))) != 0) || (((_la-164)&-(0x1f+1)) == 0 && ((1<<uint((_la-164)))&((1<<(VisualBasic6ParserTYPE-164))|(1<<(VisualBasic6ParserTYPEOF-164))|(1<<(VisualBasic6ParserUNLOAD-164))|(1<<(VisualBasic6ParserUNLOCK-164))|(1<<(VisualBasic6ParserUNTIL-164))|(1<<(VisualBasic6ParserVARIANT-164))|(1<<(VisualBasic6ParserVERSION-164))|(1<<(VisualBasic6ParserWEND-164))|(1<<(VisualBasic6ParserWHILE-164))|(1<<(VisualBasic6ParserWIDTH-164))|(1<<(VisualBasic6ParserWITH-164))|(1<<(VisualBasic6ParserWITHEVENTS-164))|(1<<(VisualBasic6ParserWRITE-164))|(1<<(VisualBasic6ParserXOR-164)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

func (p *VisualBasic6Parser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 110:
		var t *ValueStmtContext = nil
		if localctx != nil {
			t = localctx.(*ValueStmtContext)
		}
		return p.ValueStmt_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *VisualBasic6Parser) ValueStmt_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 1:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 13)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 9)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 3)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
