// Generated from ./parser/Og.g4 by ANTLR 4.7.1.

package parser // Og

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"

	"github.com/champii/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, 86, 1032,
	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, 3, 2, 3, 2, 3, 2, 3, 2,
	3, 2, 7, 2, 224, 10, 2, 12, 2, 14, 2, 227, 11, 2, 3, 2, 3, 2, 3, 2, 7,
	2, 232, 10, 2, 12, 2, 14, 2, 235, 11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 5, 3,
	241, 10, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 5, 5, 254, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 7, 6, 261, 10, 6,
	12, 6, 14, 6, 264, 11, 6, 3, 6, 5, 6, 267, 10, 6, 3, 7, 3, 7, 3, 7, 5,
	7, 272, 10, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 5, 9, 279, 10, 9, 3, 10, 3,
	10, 3, 10, 5, 10, 284, 10, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11,
	7, 11, 292, 10, 11, 12, 11, 14, 11, 295, 11, 11, 3, 11, 5, 11, 298, 10,
	11, 3, 12, 3, 12, 5, 12, 302, 10, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13,
	3, 13, 7, 13, 310, 10, 13, 12, 13, 14, 13, 313, 11, 13, 3, 14, 3, 14, 3,
	14, 7, 14, 318, 10, 14, 12, 14, 14, 14, 321, 11, 14, 3, 15, 3, 15, 3, 15,
	3, 15, 3, 15, 3, 15, 7, 15, 329, 10, 15, 12, 15, 14, 15, 332, 11, 15, 3,
	15, 5, 15, 335, 10, 15, 3, 15, 3, 15, 5, 15, 339, 10, 15, 3, 16, 3, 16,
	3, 16, 3, 17, 3, 17, 3, 17, 5, 17, 347, 10, 17, 3, 18, 3, 18, 3, 18, 3,
	18, 5, 18, 353, 10, 18, 3, 19, 3, 19, 3, 19, 5, 19, 358, 10, 19, 3, 20,
	3, 20, 3, 20, 5, 20, 363, 10, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3,
	21, 3, 21, 3, 21, 7, 21, 373, 10, 21, 12, 21, 14, 21, 376, 11, 21, 3, 21,
	5, 21, 379, 10, 21, 3, 22, 3, 22, 3, 22, 3, 22, 5, 22, 385, 10, 22, 3,
	22, 3, 22, 5, 22, 389, 10, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24,
	3, 24, 7, 24, 398, 10, 24, 12, 24, 14, 24, 401, 11, 24, 3, 25, 3, 25, 3,
	25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25,
	3, 25, 3, 25, 5, 25, 418, 10, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3,
	26, 5, 26, 426, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28,
	3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 5, 30, 440, 10, 30, 3, 30, 3, 30, 3,
	31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33,
	3, 34, 3, 34, 5, 34, 457, 10, 34, 3, 35, 3, 35, 5, 35, 461, 10, 35, 3,
	36, 3, 36, 5, 36, 465, 10, 36, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 39,
	3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 479, 10, 40, 3, 40, 3,
	40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 488, 10, 40, 3, 40, 3, 40,
	3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 497, 10, 40, 5, 40, 499, 10,
	40, 5, 40, 501, 10, 40, 3, 41, 3, 41, 5, 41, 505, 10, 41, 3, 42, 3, 42,
	3, 42, 3, 42, 5, 42, 511, 10, 42, 3, 42, 5, 42, 514, 10, 42, 3, 42, 3,
	42, 7, 42, 518, 10, 42, 12, 42, 14, 42, 521, 11, 42, 3, 42, 3, 42, 3, 43,
	3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 5, 44, 531, 10, 44, 3, 45, 3, 45, 3,
	45, 3, 45, 5, 45, 537, 10, 45, 3, 45, 3, 45, 3, 45, 7, 45, 542, 10, 45,
	12, 45, 14, 45, 545, 11, 45, 3, 45, 3, 45, 3, 46, 3, 46, 5, 46, 551, 10,
	46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47,
	3, 48, 3, 48, 5, 48, 565, 10, 48, 3, 49, 3, 49, 3, 49, 7, 49, 570, 10,
	49, 12, 49, 14, 49, 573, 11, 49, 3, 50, 3, 50, 3, 50, 7, 50, 578, 10, 50,
	12, 50, 14, 50, 581, 11, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51,
	5, 51, 589, 10, 51, 3, 52, 3, 52, 5, 52, 593, 10, 52, 3, 52, 5, 52, 596,
	10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 604, 10, 53, 3,
	53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 612, 10, 54, 3, 54, 3, 54,
	3, 54, 3, 55, 5, 55, 618, 10, 55, 3, 55, 3, 55, 5, 55, 622, 10, 55, 3,
	55, 3, 55, 5, 55, 626, 10, 55, 3, 56, 3, 56, 5, 56, 630, 10, 56, 3, 56,
	3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 5, 57, 638, 10, 57, 3, 58, 3, 58, 3,
	58, 3, 58, 3, 58, 3, 58, 5, 58, 646, 10, 58, 3, 59, 3, 59, 5, 59, 650,
	10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60,
	660, 10, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 63, 3,
	63, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 5, 65, 676, 10, 65, 3, 65, 3, 65,
	3, 65, 3, 65, 7, 65, 682, 10, 65, 12, 65, 14, 65, 685, 11, 65, 3, 65, 5,
	65, 688, 10, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67,
	3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5,
	69, 708, 10, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70,
	3, 70, 5, 70, 719, 10, 70, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 5, 72, 726,
	10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 733, 10, 72, 3, 72, 5,
	72, 736, 10, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 7, 74,
	745, 10, 74, 12, 74, 14, 74, 748, 11, 74, 3, 75, 3, 75, 3, 75, 5, 75, 753,
	10, 75, 5, 75, 755, 10, 75, 3, 75, 5, 75, 758, 10, 75, 3, 76, 3, 76, 3,
	76, 7, 76, 763, 10, 76, 12, 76, 14, 76, 766, 11, 76, 3, 77, 5, 77, 769,
	10, 77, 3, 77, 5, 77, 772, 10, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 79, 3,
	79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 785, 10, 79, 3, 80, 3, 80,
	3, 80, 5, 80, 790, 10, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3,
	81, 5, 81, 799, 10, 81, 3, 82, 3, 82, 3, 82, 5, 82, 804, 10, 82, 3, 83,
	3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 814, 10, 84, 3,
	85, 3, 85, 5, 85, 818, 10, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86,
	3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 831, 10, 86, 3, 87, 3, 87, 3,
	87, 5, 87, 836, 10, 87, 5, 87, 838, 10, 87, 3, 87, 3, 87, 3, 88, 3, 88,
	5, 88, 844, 10, 88, 3, 88, 7, 88, 847, 10, 88, 12, 88, 14, 88, 850, 11,
	88, 3, 89, 3, 89, 3, 89, 5, 89, 855, 10, 89, 3, 89, 3, 89, 3, 90, 3, 90,
	3, 90, 5, 90, 862, 10, 90, 3, 91, 3, 91, 5, 91, 866, 10, 91, 3, 92, 3,
	92, 5, 92, 870, 10, 92, 3, 92, 5, 92, 873, 10, 92, 3, 92, 3, 92, 3, 92,
	3, 92, 7, 92, 879, 10, 92, 12, 92, 14, 92, 882, 11, 92, 3, 92, 5, 92, 885,
	10, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 5, 93, 892, 10, 93, 3, 93, 5,
	93, 895, 10, 93, 3, 93, 5, 93, 898, 10, 93, 3, 94, 5, 94, 901, 10, 94,
	3, 94, 3, 94, 3, 95, 5, 95, 906, 10, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3,
	96, 3, 97, 3, 97, 3, 97, 5, 97, 916, 10, 97, 3, 97, 3, 97, 7, 97, 920,
	10, 97, 12, 97, 14, 97, 923, 11, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98,
	5, 98, 930, 10, 98, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100,
	3, 101, 3, 101, 5, 101, 941, 10, 101, 3, 101, 3, 101, 5, 101, 945, 10,
	101, 3, 101, 5, 101, 948, 10, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101,
	5, 101, 955, 10, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3,
	102, 3, 103, 5, 103, 965, 10, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103,
	5, 103, 972, 10, 103, 5, 103, 974, 10, 103, 3, 103, 5, 103, 977, 10, 103,
	3, 103, 5, 103, 980, 10, 103, 5, 103, 982, 10, 103, 3, 103, 3, 103, 3,
	104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3,
	105, 3, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1000, 10, 105, 3, 106, 3,
	106, 3, 106, 3, 106, 3, 106, 3, 106, 7, 106, 1008, 10, 106, 12, 106, 14,
	106, 1011, 11, 106, 3, 107, 3, 107, 3, 107, 5, 107, 1016, 10, 107, 3, 108,
	3, 108, 3, 108, 3, 108, 5, 108, 1022, 10, 108, 3, 108, 3, 108, 3, 109,
	3, 109, 3, 109, 3, 109, 5, 109, 1030, 10, 109, 3, 109, 2, 4, 192, 210,
	110, 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, 2, 12, 3, 2, 3, 4, 4,
	2, 11, 11, 71, 71, 4, 2, 71, 71, 81, 81, 4, 2, 14, 14, 71, 71, 3, 2, 21,
	22, 4, 2, 18, 18, 23, 32, 3, 2, 59, 60, 3, 2, 63, 64, 6, 2, 18, 18, 23,
	32, 56, 57, 65, 70, 8, 2, 4, 4, 18, 18, 20, 20, 23, 24, 26, 26, 31, 31,
	2, 1092, 2, 218, 3, 2, 2, 2, 4, 240, 3, 2, 2, 2, 6, 244, 3, 2, 2, 2, 8,
	247, 3, 2, 2, 2, 10, 266, 3, 2, 2, 2, 12, 268, 3, 2, 2, 2, 14, 273, 3,
	2, 2, 2, 16, 278, 3, 2, 2, 2, 18, 283, 3, 2, 2, 2, 20, 285, 3, 2, 2, 2,
	22, 299, 3, 2, 2, 2, 24, 306, 3, 2, 2, 2, 26, 314, 3, 2, 2, 2, 28, 338,
	3, 2, 2, 2, 30, 340, 3, 2, 2, 2, 32, 343, 3, 2, 2, 2, 34, 348, 3, 2, 2,
	2, 36, 354, 3, 2, 2, 2, 38, 359, 3, 2, 2, 2, 40, 366, 3, 2, 2, 2, 42, 380,
	3, 2, 2, 2, 44, 390, 3, 2, 2, 2, 46, 399, 3, 2, 2, 2, 48, 417, 3, 2, 2,
	2, 50, 425, 3, 2, 2, 2, 52, 427, 3, 2, 2, 2, 54, 431, 3, 2, 2, 2, 56, 434,
	3, 2, 2, 2, 58, 439, 3, 2, 2, 2, 60, 443, 3, 2, 2, 2, 62, 447, 3, 2, 2,
	2, 64, 449, 3, 2, 2, 2, 66, 454, 3, 2, 2, 2, 68, 458, 3, 2, 2, 2, 70, 462,
	3, 2, 2, 2, 72, 466, 3, 2, 2, 2, 74, 469, 3, 2, 2, 2, 76, 471, 3, 2, 2,
	2, 78, 474, 3, 2, 2, 2, 80, 504, 3, 2, 2, 2, 82, 506, 3, 2, 2, 2, 84, 524,
	3, 2, 2, 2, 86, 530, 3, 2, 2, 2, 88, 532, 3, 2, 2, 2, 90, 550, 3, 2, 2,
	2, 92, 558, 3, 2, 2, 2, 94, 564, 3, 2, 2, 2, 96, 566, 3, 2, 2, 2, 98, 574,
	3, 2, 2, 2, 100, 584, 3, 2, 2, 2, 102, 595, 3, 2, 2, 2, 104, 603, 3, 2,
	2, 2, 106, 607, 3, 2, 2, 2, 108, 617, 3, 2, 2, 2, 110, 629, 3, 2, 2, 2,
	112, 634, 3, 2, 2, 2, 114, 645, 3, 2, 2, 2, 116, 649, 3, 2, 2, 2, 118,
	659, 3, 2, 2, 2, 120, 661, 3, 2, 2, 2, 122, 666, 3, 2, 2, 2, 124, 668,
	3, 2, 2, 2, 126, 670, 3, 2, 2, 2, 128, 673, 3, 2, 2, 2, 130, 689, 3, 2,
	2, 2, 132, 693, 3, 2, 2, 2, 134, 699, 3, 2, 2, 2, 136, 707, 3, 2, 2, 2,
	138, 718, 3, 2, 2, 2, 140, 720, 3, 2, 2, 2, 142, 735, 3, 2, 2, 2, 144,
	737, 3, 2, 2, 2, 146, 741, 3, 2, 2, 2, 148, 757, 3, 2, 2, 2, 150, 759,
	3, 2, 2, 2, 152, 768, 3, 2, 2, 2, 154, 775, 3, 2, 2, 2, 156, 784, 3, 2,
	2, 2, 158, 789, 3, 2, 2, 2, 160, 798, 3, 2, 2, 2, 162, 803, 3, 2, 2, 2,
	164, 805, 3, 2, 2, 2, 166, 813, 3, 2, 2, 2, 168, 815, 3, 2, 2, 2, 170,
	830, 3, 2, 2, 2, 172, 832, 3, 2, 2, 2, 174, 841, 3, 2, 2, 2, 176, 854,
	3, 2, 2, 2, 178, 861, 3, 2, 2, 2, 180, 865, 3, 2, 2, 2, 182, 867, 3, 2,
	2, 2, 184, 897, 3, 2, 2, 2, 186, 900, 3, 2, 2, 2, 188, 905, 3, 2, 2, 2,
	190, 909, 3, 2, 2, 2, 192, 915, 3, 2, 2, 2, 194, 929, 3, 2, 2, 2, 196,
	931, 3, 2, 2, 2, 198, 934, 3, 2, 2, 2, 200, 938, 3, 2, 2, 2, 202, 958,
	3, 2, 2, 2, 204, 964, 3, 2, 2, 2, 206, 985, 3, 2, 2, 2, 208, 999, 3, 2,
	2, 2, 210, 1001, 3, 2, 2, 2, 212, 1015, 3, 2, 2, 2, 214, 1017, 3, 2, 2,
	2, 216, 1029, 3, 2, 2, 2, 218, 219, 5, 6, 4, 2, 219, 225, 5, 216, 109,
	2, 220, 221, 5, 8, 5, 2, 221, 222, 5, 216, 109, 2, 222, 224, 3, 2, 2, 2,
	223, 220, 3, 2, 2, 2, 224, 227, 3, 2, 2, 2, 225, 223, 3, 2, 2, 2, 225,
	226, 3, 2, 2, 2, 226, 233, 3, 2, 2, 2, 227, 225, 3, 2, 2, 2, 228, 229,
	5, 16, 9, 2, 229, 230, 5, 216, 109, 2, 230, 232, 3, 2, 2, 2, 231, 228,
	3, 2, 2, 2, 232, 235, 3, 2, 2, 2, 233, 231, 3, 2, 2, 2, 233, 234, 3, 2,
	2, 2, 234, 236, 3, 2, 2, 2, 235, 233, 3, 2, 2, 2, 236, 237, 7, 2, 2, 3,
	237, 3, 3, 2, 2, 2, 238, 241, 5, 16, 9, 2, 239, 241, 5, 48, 25, 2, 240,
	238, 3, 2, 2, 2, 240, 239, 3, 2, 2, 2, 241, 242, 3, 2, 2, 2, 242, 243,
	7, 2, 2, 3, 243, 5, 3, 2, 2, 2, 244, 245, 9, 2, 2, 2, 245, 246, 7, 71,
	2, 2, 246, 7, 3, 2, 2, 2, 247, 253, 7, 5, 2, 2, 248, 254, 5, 10, 6, 2,
	249, 250, 7, 6, 2, 2, 250, 251, 5, 10, 6, 2, 251, 252, 7, 7, 2, 2, 252,
	254, 3, 2, 2, 2, 253, 248, 3, 2, 2, 2, 253, 249, 3, 2, 2, 2, 254, 9, 3,
	2, 2, 2, 255, 267, 5, 12, 7, 2, 256, 262, 7, 8, 2, 2, 257, 258, 5, 12,
	7, 2, 258, 259, 5, 216, 109, 2, 259, 261, 3, 2, 2, 2, 260, 257, 3, 2, 2,
	2, 261, 264, 3, 2, 2, 2, 262, 260, 3, 2, 2, 2, 262, 263, 3, 2, 2, 2, 263,
	265, 3, 2, 2, 2, 264, 262, 3, 2, 2, 2, 265, 267, 7, 9, 2, 2, 266, 255,
	3, 2, 2, 2, 266, 256, 3, 2, 2, 2, 267, 11, 3, 2, 2, 2, 268, 271, 5, 14,
	8, 2, 269, 270, 7, 10, 2, 2, 270, 272, 9, 3, 2, 2, 271, 269, 3, 2, 2, 2,
	271, 272, 3, 2, 2, 2, 272, 13, 3, 2, 2, 2, 273, 274, 9, 4, 2, 2, 274, 15,
	3, 2, 2, 2, 275, 279, 5, 18, 10, 2, 276, 279, 5, 32, 17, 2, 277, 279, 5,
	36, 19, 2, 278, 275, 3, 2, 2, 2, 278, 276, 3, 2, 2, 2, 278, 277, 3, 2,
	2, 2, 279, 17, 3, 2, 2, 2, 280, 284, 5, 20, 11, 2, 281, 284, 5, 28, 15,
	2, 282, 284, 5, 40, 21, 2, 283, 280, 3, 2, 2, 2, 283, 281, 3, 2, 2, 2,
	283, 282, 3, 2, 2, 2, 284, 19, 3, 2, 2, 2, 285, 297, 7, 12, 2, 2, 286,
	298, 5, 22, 12, 2, 287, 293, 7, 6, 2, 2, 288, 289, 5, 22, 12, 2, 289, 290,
	5, 216, 109, 2, 290, 292, 3, 2, 2, 2, 291, 288, 3, 2, 2, 2, 292, 295, 3,
	2, 2, 2, 293, 291, 3, 2, 2, 2, 293, 294, 3, 2, 2, 2, 294, 296, 3, 2, 2,
	2, 295, 293, 3, 2, 2, 2, 296, 298, 7, 7, 2, 2, 297, 286, 3, 2, 2, 2, 297,
	287, 3, 2, 2, 2, 298, 21, 3, 2, 2, 2, 299, 301, 5, 24, 13, 2, 300, 302,
	5, 114, 58, 2, 301, 300, 3, 2, 2, 2, 301, 302, 3, 2, 2, 2, 302, 303, 3,
	2, 2, 2, 303, 304, 7, 13, 2, 2, 304, 305, 5, 26, 14, 2, 305, 23, 3, 2,
	2, 2, 306, 311, 9, 5, 2, 2, 307, 308, 7, 15, 2, 2, 308, 310, 9, 5, 2, 2,
	309, 307, 3, 2, 2, 2, 310, 313, 3, 2, 2, 2, 311, 309, 3, 2, 2, 2, 311,
	312, 3, 2, 2, 2, 312, 25, 3, 2, 2, 2, 313, 311, 3, 2, 2, 2, 314, 319, 5,
	210, 106, 2, 315, 316, 7, 15, 2, 2, 316, 318, 5, 210, 106, 2, 317, 315,
	3, 2, 2, 2, 318, 321, 3, 2, 2, 2, 319, 317, 3, 2, 2, 2, 319, 320, 3, 2,
	2, 2, 320, 27, 3, 2, 2, 2, 321, 319, 3, 2, 2, 2, 322, 334, 7, 16, 2, 2,
	323, 335, 5, 30, 16, 2, 324, 330, 7, 6, 2, 2, 325, 326, 5, 30, 16, 2, 326,
	327, 5, 216, 109, 2, 327, 329, 3, 2, 2, 2, 328, 325, 3, 2, 2, 2, 329, 332,
	3, 2, 2, 2, 330, 328, 3, 2, 2, 2, 330, 331, 3, 2, 2, 2, 331, 333, 3, 2,
	2, 2, 332, 330, 3, 2, 2, 2, 333, 335, 7, 7, 2, 2, 334, 323, 3, 2, 2, 2,
	334, 324, 3, 2, 2, 2, 335, 339, 3, 2, 2, 2, 336, 339, 5, 182, 92, 2, 337,
	339, 5, 128, 65, 2, 338, 322, 3, 2, 2, 2, 338, 336, 3, 2, 2, 2, 338, 337,
	3, 2, 2, 2, 339, 29, 3, 2, 2, 2, 340, 341, 7, 71, 2, 2, 341, 342, 5, 114,
	58, 2, 342, 31, 3, 2, 2, 2, 343, 346, 7, 71, 2, 2, 344, 347, 5, 34, 18,
	2, 345, 347, 5, 142, 72, 2, 346, 344, 3, 2, 2, 2, 346, 345, 3, 2, 2, 2,
	347, 33, 3, 2, 2, 2, 348, 349, 5, 142, 72, 2, 349, 352, 7, 74, 2, 2, 350,
	353, 5, 44, 23, 2, 351, 353, 5, 48, 25, 2, 352, 350, 3, 2, 2, 2, 352, 351,
	3, 2, 2, 2, 353, 35, 3, 2, 2, 2, 354, 357, 5, 38, 20, 2, 355, 358, 5, 34,
	18, 2, 356, 358, 5, 142, 72, 2, 357, 355, 3, 2, 2, 2, 357, 356, 3, 2, 2,
	2, 358, 37, 3, 2, 2, 2, 359, 360, 7, 71, 2, 2, 360, 362, 7, 17, 2, 2, 361,
	363, 7, 18, 2, 2, 362, 361, 3, 2, 2, 2, 362, 363, 3, 2, 2, 2, 363, 364,
	3, 2, 2, 2, 364, 365, 7, 71, 2, 2, 365, 39, 3, 2, 2, 2, 366, 378, 7, 19,
	2, 2, 367, 379, 5, 42, 22, 2, 368, 374, 7, 6, 2, 2, 369, 370, 5, 42, 22,
	2, 370, 371, 5, 216, 109, 2, 371, 373, 3, 2, 2, 2, 372, 369, 3, 2, 2, 2,
	373, 376, 3, 2, 2, 2, 374, 372, 3, 2, 2, 2, 374, 375, 3, 2, 2, 2, 375,
	377, 3, 2, 2, 2, 376, 374, 3, 2, 2, 2, 377, 379, 7, 7, 2, 2, 378, 367,
	3, 2, 2, 2, 378, 368, 3, 2, 2, 2, 379, 41, 3, 2, 2, 2, 380, 388, 5, 24,
	13, 2, 381, 384, 5, 114, 58, 2, 382, 383, 7, 13, 2, 2, 383, 385, 5, 48,
	25, 2, 384, 382, 3, 2, 2, 2, 384, 385, 3, 2, 2, 2, 385, 389, 3, 2, 2, 2,
	386, 387, 7, 13, 2, 2, 387, 389, 5, 26, 14, 2, 388, 381, 3, 2, 2, 2, 388,
	386, 3, 2, 2, 2, 389, 43, 3, 2, 2, 2, 390, 391, 7, 8, 2, 2, 391, 392, 5,
	46, 24, 2, 392, 393, 7, 9, 2, 2, 393, 45, 3, 2, 2, 2, 394, 395, 5, 48,
	25, 2, 395, 396, 5, 216, 109, 2, 396, 398, 3, 2, 2, 2, 397, 394, 3, 2,
	2, 2, 398, 401, 3, 2, 2, 2, 399, 397, 3, 2, 2, 2, 399, 400, 3, 2, 2, 2,
	400, 47, 3, 2, 2, 2, 401, 399, 3, 2, 2, 2, 402, 418, 5, 106, 54, 2, 403,
	418, 5, 50, 26, 2, 404, 418, 5, 112, 57, 2, 405, 418, 5, 66, 34, 2, 406,
	418, 5, 68, 35, 2, 407, 418, 5, 70, 36, 2, 408, 418, 5, 72, 37, 2, 409,
	418, 5, 74, 38, 2, 410, 418, 5, 78, 40, 2, 411, 418, 5, 80, 41, 2, 412,
	418, 5, 98, 50, 2, 413, 418, 5, 76, 39, 2, 414, 418, 5, 64, 33, 2, 415,
	418, 5, 44, 23, 2, 416, 418, 5, 18, 10, 2, 417, 402, 3, 2, 2, 2, 417, 403,
	3, 2, 2, 2, 417, 404, 3, 2, 2, 2, 417, 405, 3, 2, 2, 2, 417, 406, 3, 2,
	2, 2, 417, 407, 3, 2, 2, 2, 417, 408, 3, 2, 2, 2, 417, 409, 3, 2, 2, 2,
	417, 410, 3, 2, 2, 2, 417, 411, 3, 2, 2, 2, 417, 412, 3, 2, 2, 2, 417,
	413, 3, 2, 2, 2, 417, 414, 3, 2, 2, 2, 417, 415, 3, 2, 2, 2, 417, 416,
	3, 2, 2, 2, 418, 49, 3, 2, 2, 2, 419, 426, 5, 52, 27, 2, 420, 426, 5, 54,
	28, 2, 421, 426, 5, 60, 31, 2, 422, 426, 5, 56, 29, 2, 423, 426, 5, 210,
	106, 2, 424, 426, 5, 62, 32, 2, 425, 419, 3, 2, 2, 2, 425, 420, 3, 2, 2,
	2, 425, 421, 3, 2, 2, 2, 425, 422, 3, 2, 2, 2, 425, 423, 3, 2, 2, 2, 425,
	424, 3, 2, 2, 2, 426, 51, 3, 2, 2, 2, 427, 428, 5, 210, 106, 2, 428, 429,
	7, 20, 2, 2, 429, 430, 5, 210, 106, 2, 430, 53, 3, 2, 2, 2, 431, 432, 5,
	210, 106, 2, 432, 433, 9, 6, 2, 2, 433, 55, 3, 2, 2, 2, 434, 435, 5, 26,
	14, 2, 435, 436, 5, 58, 30, 2, 436, 437, 5, 26, 14, 2, 437, 57, 3, 2, 2,
	2, 438, 440, 9, 7, 2, 2, 439, 438, 3, 2, 2, 2, 439, 440, 3, 2, 2, 2, 440,
	441, 3, 2, 2, 2, 441, 442, 7, 13, 2, 2, 442, 59, 3, 2, 2, 2, 443, 444,
	5, 24, 13, 2, 444, 445, 7, 33, 2, 2, 445, 446, 5, 26, 14, 2, 446, 61, 3,
	2, 2, 2, 447, 448, 7, 34, 2, 2, 448, 63, 3, 2, 2, 2, 449, 450, 7, 35, 2,
	2, 450, 451, 7, 71, 2, 2, 451, 452, 7, 10, 2, 2, 452, 453, 5, 48, 25, 2,
	453, 65, 3, 2, 2, 2, 454, 456, 7, 36, 2, 2, 455, 457, 5, 26, 14, 2, 456,
	455, 3, 2, 2, 2, 456, 457, 3, 2, 2, 2, 457, 67, 3, 2, 2, 2, 458, 460, 7,
	37, 2, 2, 459, 461, 7, 71, 2, 2, 460, 459, 3, 2, 2, 2, 460, 461, 3, 2,
	2, 2, 461, 69, 3, 2, 2, 2, 462, 464, 7, 38, 2, 2, 463, 465, 7, 71, 2, 2,
	464, 463, 3, 2, 2, 2, 464, 465, 3, 2, 2, 2, 465, 71, 3, 2, 2, 2, 466, 467,
	7, 39, 2, 2, 467, 468, 7, 71, 2, 2, 468, 73, 3, 2, 2, 2, 469, 470, 7, 40,
	2, 2, 470, 75, 3, 2, 2, 2, 471, 472, 7, 41, 2, 2, 472, 473, 5, 210, 106,
	2, 473, 77, 3, 2, 2, 2, 474, 478, 7, 42, 2, 2, 475, 476, 5, 50, 26, 2,
	476, 477, 7, 34, 2, 2, 477, 479, 3, 2, 2, 2, 478, 475, 3, 2, 2, 2, 478,
	479, 3, 2, 2, 2, 479, 480, 3, 2, 2, 2, 480, 487, 5, 210, 106, 2, 481, 482,
	7, 43, 2, 2, 482, 483, 5, 48, 25, 2, 483, 484, 5, 216, 109, 2, 484, 488,
	3, 2, 2, 2, 485, 486, 7, 34, 2, 2, 486, 488, 5, 44, 23, 2, 487, 481, 3,
	2, 2, 2, 487, 485, 3, 2, 2, 2, 488, 500, 3, 2, 2, 2, 489, 498, 7, 44, 2,
	2, 490, 499, 5, 78, 40, 2, 491, 492, 7, 43, 2, 2, 492, 493, 5, 48, 25,
	2, 493, 494, 5, 216, 109, 2, 494, 497, 3, 2, 2, 2, 495, 497, 5, 44, 23,
	2, 496, 491, 3, 2, 2, 2, 496, 495, 3, 2, 2, 2, 497, 499, 3, 2, 2, 2, 498,
	490, 3, 2, 2, 2, 498, 496, 3, 2, 2, 2, 499, 501, 3, 2, 2, 2, 500, 489,
	3, 2, 2, 2, 500, 501, 3, 2, 2, 2, 501, 79, 3, 2, 2, 2, 502, 505, 5, 82,
	42, 2, 503, 505, 5, 88, 45, 2, 504, 502, 3, 2, 2, 2, 504, 503, 3, 2, 2,
	2, 505, 81, 3, 2, 2, 2, 506, 510, 7, 45, 2, 2, 507, 508, 5, 50, 26, 2,
	508, 509, 7, 34, 2, 2, 509, 511, 3, 2, 2, 2, 510, 507, 3, 2, 2, 2, 510,
	511, 3, 2, 2, 2, 511, 513, 3, 2, 2, 2, 512, 514, 5, 210, 106, 2, 513, 512,
	3, 2, 2, 2, 513, 514, 3, 2, 2, 2, 514, 515, 3, 2, 2, 2, 515, 519, 7, 8,
	2, 2, 516, 518, 5, 84, 43, 2, 517, 516, 3, 2, 2, 2, 518, 521, 3, 2, 2,
	2, 519, 517, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 522, 3, 2, 2, 2, 521,
	519, 3, 2, 2, 2, 522, 523, 7, 9, 2, 2, 523, 83, 3, 2, 2, 2, 524, 525, 5,
	86, 44, 2, 525, 526, 7, 43, 2, 2, 526, 527, 5, 46, 24, 2, 527, 85, 3, 2,
	2, 2, 528, 531, 5, 26, 14, 2, 529, 531, 7, 14, 2, 2, 530, 528, 3, 2, 2,
	2, 530, 529, 3, 2, 2, 2, 531, 87, 3, 2, 2, 2, 532, 536, 7, 45, 2, 2, 533,
	534, 5, 50, 26, 2, 534, 535, 7, 34, 2, 2, 535, 537, 3, 2, 2, 2, 536, 533,
	3, 2, 2, 2, 536, 537, 3, 2, 2, 2, 537, 538, 3, 2, 2, 2, 538, 539, 5, 90,
	46, 2, 539, 543, 7, 8, 2, 2, 540, 542, 5, 92, 47, 2, 541, 540, 3, 2, 2,
	2, 542, 545, 3, 2, 2, 2, 543, 541, 3, 2, 2, 2, 543, 544, 3, 2, 2, 2, 544,
	546, 3, 2, 2, 2, 545, 543, 3, 2, 2, 2, 546, 547, 7, 9, 2, 2, 547, 89, 3,
	2, 2, 2, 548, 549, 7, 71, 2, 2, 549, 551, 7, 33, 2, 2, 550, 548, 3, 2,
	2, 2, 550, 551, 3, 2, 2, 2, 551, 552, 3, 2, 2, 2, 552, 553, 5, 192, 97,
	2, 553, 554, 7, 11, 2, 2, 554, 555, 7, 6, 2, 2, 555, 556, 7, 16, 2, 2,
	556, 557, 7, 7, 2, 2, 557, 91, 3, 2, 2, 2, 558, 559, 5, 94, 48, 2, 559,
	560, 7, 43, 2, 2, 560, 561, 5, 46, 24, 2, 561, 93, 3, 2, 2, 2, 562, 565,
	5, 96, 49, 2, 563, 565, 7, 14, 2, 2, 564, 562, 3, 2, 2, 2, 564, 563, 3,
	2, 2, 2, 565, 95, 3, 2, 2, 2, 566, 571, 5, 114, 58, 2, 567, 568, 7, 15,
	2, 2, 568, 570, 5, 114, 58, 2, 569, 567, 3, 2, 2, 2, 570, 573, 3, 2, 2,
	2, 571, 569, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572, 97, 3, 2, 2, 2, 573,
	571, 3, 2, 2, 2, 574, 575, 7, 46, 2, 2, 575, 579, 7, 8, 2, 2, 576, 578,
	5, 100, 51, 2, 577, 576, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3,
	2, 2, 2, 579, 580, 3, 2, 2, 2, 580, 582, 3, 2, 2, 2, 581, 579, 3, 2, 2,
	2, 582, 583, 7, 9, 2, 2, 583, 99, 3, 2, 2, 2, 584, 585, 5, 102, 52, 2,
	585, 588, 7, 43, 2, 2, 586, 589, 5, 44, 23, 2, 587, 589, 5, 48, 25, 2,
	588, 586, 3, 2, 2, 2, 588, 587, 3, 2, 2, 2, 589, 101, 3, 2, 2, 2, 590,
	593, 5, 52, 27, 2, 591, 593, 5, 104, 53, 2, 592, 590, 3, 2, 2, 2, 592,
	591, 3, 2, 2, 2, 593, 596, 3, 2, 2, 2, 594, 596, 7, 14, 2, 2, 595, 592,
	3, 2, 2, 2, 595, 594, 3, 2, 2, 2, 596, 103, 3, 2, 2, 2, 597, 598, 5, 26,
	14, 2, 598, 599, 7, 13, 2, 2, 599, 604, 3, 2, 2, 2, 600, 601, 5, 24, 13,
	2, 601, 602, 7, 33, 2, 2, 602, 604, 3, 2, 2, 2, 603, 597, 3, 2, 2, 2, 603,
	600, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 606,
	5, 210, 106, 2, 606, 105, 3, 2, 2, 2, 607, 611, 7, 47, 2, 2, 608, 612,
	5, 210, 106, 2, 609, 612, 5, 110, 56, 2, 610, 612, 5, 108, 55, 2, 611,
	608, 3, 2, 2, 2, 611, 609, 3, 2, 2, 2, 611, 610, 3, 2, 2, 2, 611, 612,
	3, 2, 2, 2, 612, 613, 3, 2, 2, 2, 613, 614, 7, 34, 2, 2, 614, 615, 5, 44,
	23, 2, 615, 107, 3, 2, 2, 2, 616, 618, 5, 50, 26, 2, 617, 616, 3, 2, 2,
	2, 617, 618, 3, 2, 2, 2, 618, 619, 3, 2, 2, 2, 619, 621, 7, 34, 2, 2, 620,
	622, 5, 210, 106, 2, 621, 620, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2, 622, 623,
	3, 2, 2, 2, 623, 625, 7, 34, 2, 2, 624, 626, 5, 50, 26, 2, 625, 624, 3,
	2, 2, 2, 625, 626, 3, 2, 2, 2, 626, 109, 3, 2, 2, 2, 627, 630, 5, 24, 13,
	2, 628, 630, 5, 26, 14, 2, 629, 627, 3, 2, 2, 2, 629, 628, 3, 2, 2, 2,
	630, 631, 3, 2, 2, 2, 631, 632, 7, 48, 2, 2, 632, 633, 5, 210, 106, 2,
	633, 111, 3, 2, 2, 2, 634, 637, 7, 49, 2, 2, 635, 638, 5, 34, 18, 2, 636,
	638, 5, 210, 106, 2, 637, 635, 3, 2, 2, 2, 637, 636, 3, 2, 2, 2, 638, 113,
	3, 2, 2, 2, 639, 646, 5, 116, 59, 2, 640, 646, 5, 118, 60, 2, 641, 642,
	7, 6, 2, 2, 642, 643, 5, 114, 58, 2, 643, 644, 7, 7, 2, 2, 644, 646, 3,
	2, 2, 2, 645, 639, 3, 2, 2, 2, 645, 640, 3, 2, 2, 2, 645, 641, 3, 2, 2,
	2, 646, 115, 3, 2, 2, 2, 647, 650, 5, 166, 84, 2, 648, 650, 7, 71, 2, 2,
	649, 647, 3, 2, 2, 2, 649, 648, 3, 2, 2, 2, 650, 117, 3, 2, 2, 2, 651,
	660, 5, 120, 61, 2, 652, 660, 5, 182, 92, 2, 653, 660, 5, 126, 64, 2, 654,
	660, 5, 140, 71, 2, 655, 660, 5, 128, 65, 2, 656, 660, 5, 130, 66, 2, 657,
	660, 5, 132, 67, 2, 658, 660, 5, 134, 68, 2, 659, 651, 3, 2, 2, 2, 659,
	652, 3, 2, 2, 2, 659, 653, 3, 2, 2, 2, 659, 654, 3, 2, 2, 2, 659, 655,
	3, 2, 2, 2, 659, 656, 3, 2, 2, 2, 659, 657, 3, 2, 2, 2, 659, 658, 3, 2,
	2, 2, 660, 119, 3, 2, 2, 2, 661, 662, 7, 50, 2, 2, 662, 663, 5, 122, 62,
	2, 663, 664, 7, 51, 2, 2, 664, 665, 5, 124, 63, 2, 665, 121, 3, 2, 2, 2,
	666, 667, 5, 210, 106, 2, 667, 123, 3, 2, 2, 2, 668, 669, 5, 114, 58, 2,
	669, 125, 3, 2, 2, 2, 670, 671, 7, 18, 2, 2, 671, 672, 5, 114, 58, 2, 672,
	127, 3, 2, 2, 2, 673, 675, 7, 52, 2, 2, 674, 676, 7, 71, 2, 2, 675, 674,
	3, 2, 2, 2, 675, 676, 3, 2, 2, 2, 676, 687, 3, 2, 2, 2, 677, 683, 7, 8,
	2, 2, 678, 679, 5, 138, 70, 2, 679, 680, 5, 216, 109, 2, 680, 682, 3, 2,
	2, 2, 681, 678, 3, 2, 2, 2, 682, 685, 3, 2, 2, 2, 683, 681, 3, 2, 2, 2,
	683, 684, 3, 2, 2, 2, 684, 686, 3, 2, 2, 2, 685, 683, 3, 2, 2, 2, 686,
	688, 7, 9, 2, 2, 687, 677, 3, 2, 2, 2, 687, 688, 3, 2, 2, 2, 688, 129,
	3, 2, 2, 2, 689, 690, 7, 50, 2, 2, 690, 691, 7, 51, 2, 2, 691, 692, 5,
	124, 63, 2, 692, 131, 3, 2, 2, 2, 693, 694, 7, 53, 2, 2, 694, 695, 7, 50,
	2, 2, 695, 696, 5, 114, 58, 2, 696, 697, 7, 51, 2, 2, 697, 698, 5, 124,
	63, 2, 698, 133, 3, 2, 2, 2, 699, 700, 5, 136, 69, 2, 700, 701, 5, 124,
	63, 2, 701, 135, 3, 2, 2, 2, 702, 708, 7, 54, 2, 2, 703, 704, 7, 54, 2,
	2, 704, 708, 7, 20, 2, 2, 705, 706, 7, 20, 2, 2, 706, 708, 7, 54, 2, 2,
	707, 702, 3, 2, 2, 2, 707, 703, 3, 2, 2, 2, 707, 705, 3, 2, 2, 2, 708,
	137, 3, 2, 2, 2, 709, 710, 6, 70, 2, 2, 710, 711, 7, 71, 2, 2, 711, 712,
	5, 148, 75, 2, 712, 713, 7, 10, 2, 2, 713, 714, 5, 146, 74, 2, 714, 719,
	3, 2, 2, 2, 715, 719, 5, 116, 59, 2, 716, 717, 7, 71, 2, 2, 717, 719, 5,
	148, 75, 2, 718, 709, 3, 2, 2, 2, 718, 715, 3, 2, 2, 2, 718, 716, 3, 2,
	2, 2, 719, 139, 3, 2, 2, 2, 720, 721, 7, 55, 2, 2, 721, 722, 5, 142, 72,
	2, 722, 141, 3, 2, 2, 2, 723, 725, 6, 72, 3, 2, 724, 726, 5, 144, 73, 2,
	725, 724, 3, 2, 2, 2, 725, 726, 3, 2, 2, 2, 726, 727, 3, 2, 2, 2, 727,
	728, 5, 148, 75, 2, 728, 729, 7, 10, 2, 2, 729, 730, 5, 146, 74, 2, 730,
	736, 3, 2, 2, 2, 731, 733, 5, 144, 73, 2, 732, 731, 3, 2, 2, 2, 732, 733,
	3, 2, 2, 2, 733, 734, 3, 2, 2, 2, 734, 736, 5, 148, 75, 2, 735, 723, 3,
	2, 2, 2, 735, 732, 3, 2, 2, 2, 736, 143, 3, 2, 2, 2, 737, 738, 7, 56, 2,
	2, 738, 739, 5, 146, 74, 2, 739, 740, 7, 57, 2, 2, 740, 145, 3, 2, 2, 2,
	741, 746, 5, 114, 58, 2, 742, 743, 7, 15, 2, 2, 743, 745, 5, 114, 58, 2,
	744, 742, 3, 2, 2, 2, 745, 748, 3, 2, 2, 2, 746, 744, 3, 2, 2, 2, 746,
	747, 3, 2, 2, 2, 747, 147, 3, 2, 2, 2, 748, 746, 3, 2, 2, 2, 749, 754,
	7, 6, 2, 2, 750, 752, 5, 150, 76, 2, 751, 753, 7, 15, 2, 2, 752, 751, 3,
	2, 2, 2, 752, 753, 3, 2, 2, 2, 753, 755, 3, 2, 2, 2, 754, 750, 3, 2, 2,
	2, 754, 755, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 758, 7, 7, 2, 2, 757,
	749, 3, 2, 2, 2, 757, 758, 3, 2, 2, 2, 758, 149, 3, 2, 2, 2, 759, 764,
	5, 152, 77, 2, 760, 761, 7, 15, 2, 2, 761, 763, 5, 152, 77, 2, 762, 760,
	3, 2, 2, 2, 763, 766, 3, 2, 2, 2, 764, 762, 3, 2, 2, 2, 764, 765, 3, 2,
	2, 2, 765, 151, 3, 2, 2, 2, 766, 764, 3, 2, 2, 2, 767, 769, 5, 24, 13,
	2, 768, 767, 3, 2, 2, 2, 768, 769, 3, 2, 2, 2, 769, 771, 3, 2, 2, 2, 770,
	772, 5, 154, 78, 2, 771, 770, 3, 2, 2, 2, 771, 772, 3, 2, 2, 2, 772, 773,
	3, 2, 2, 2, 773, 774, 5, 114, 58, 2, 774, 153, 3, 2, 2, 2, 775, 776, 7,
	58, 2, 2, 776, 155, 3, 2, 2, 2, 777, 785, 5, 158, 80, 2, 778, 785, 5, 162,
	82, 2, 779, 785, 5, 206, 104, 2, 780, 781, 7, 6, 2, 2, 781, 782, 5, 210,
	106, 2, 782, 783, 7, 7, 2, 2, 783, 785, 3, 2, 2, 2, 784, 777, 3, 2, 2,
	2, 784, 778, 3, 2, 2, 2, 784, 779, 3, 2, 2, 2, 784, 780, 3, 2, 2, 2, 785,
	157, 3, 2, 2, 2, 786, 790, 5, 160, 81, 2, 787, 790, 5, 168, 85, 2, 788,
	790, 5, 190, 96, 2, 789, 786, 3, 2, 2, 2, 789, 787, 3, 2, 2, 2, 789, 788,
	3, 2, 2, 2, 790, 159, 3, 2, 2, 2, 791, 799, 7, 75, 2, 2, 792, 799, 7, 76,
	2, 2, 793, 799, 7, 77, 2, 2, 794, 799, 7, 78, 2, 2, 795, 799, 7, 81, 2,
	2, 796, 799, 9, 8, 2, 2, 797, 799, 7, 61, 2, 2, 798, 791, 3, 2, 2, 2, 798,
	792, 3, 2, 2, 2, 798, 793, 3, 2, 2, 2, 798, 794, 3, 2, 2, 2, 798, 795,
	3, 2, 2, 2, 798, 796, 3, 2, 2, 2, 798, 797, 3, 2, 2, 2, 799, 161, 3, 2,
	2, 2, 800, 804, 7, 71, 2, 2, 801, 804, 5, 166, 84, 2, 802, 804, 5, 164,
	83, 2, 803, 800, 3, 2, 2, 2, 803, 801, 3, 2, 2, 2, 803, 802, 3, 2, 2, 2,
	804, 163, 3, 2, 2, 2, 805, 806, 7, 62, 2, 2, 806, 165, 3, 2, 2, 2, 807,
	808, 7, 71, 2, 2, 808, 809, 7, 11, 2, 2, 809, 814, 7, 71, 2, 2, 810, 811,
	5, 164, 83, 2, 811, 812, 7, 71, 2, 2, 812, 814, 3, 2, 2, 2, 813, 807, 3,
	2, 2, 2, 813, 810, 3, 2, 2, 2, 814, 167, 3, 2, 2, 2, 815, 817, 5, 170,
	86, 2, 816, 818, 5, 144, 73, 2, 817, 816, 3, 2, 2, 2, 817, 818, 3, 2, 2,
	2, 818, 819, 3, 2, 2, 2, 819, 820, 5, 172, 87, 2, 820, 169, 3, 2, 2, 2,
	821, 831, 5, 182, 92, 2, 822, 831, 5, 120, 61, 2, 823, 824, 7, 50, 2, 2,
	824, 825, 7, 58, 2, 2, 825, 826, 7, 51, 2, 2, 826, 831, 5, 124, 63, 2,
	827, 831, 5, 130, 66, 2, 828, 831, 5, 132, 67, 2, 829, 831, 5, 116, 59,
	2, 830, 821, 3, 2, 2, 2, 830, 822, 3, 2, 2, 2, 830, 823, 3, 2, 2, 2, 830,
	827, 3, 2, 2, 2, 830, 828, 3, 2, 2, 2, 830, 829, 3, 2, 2, 2, 831, 171,
	3, 2, 2, 2, 832, 837, 7, 8, 2, 2, 833, 835, 5, 174, 88, 2, 834, 836, 7,
	15, 2, 2, 835, 834, 3, 2, 2, 2, 835, 836, 3, 2, 2, 2, 836, 838, 3, 2, 2,
	2, 837, 833, 3, 2, 2, 2, 837, 838, 3, 2, 2, 2, 838, 839, 3, 2, 2, 2, 839,
	840, 7, 9, 2, 2, 840, 173, 3, 2, 2, 2, 841, 848, 5, 176, 89, 2, 842, 844,
	7, 15, 2, 2, 843, 842, 3, 2, 2, 2, 843, 844, 3, 2, 2, 2, 844, 845, 3, 2,
	2, 2, 845, 847, 5, 176, 89, 2, 846, 843, 3, 2, 2, 2, 847, 850, 3, 2, 2,
	2, 848, 846, 3, 2, 2, 2, 848, 849, 3, 2, 2, 2, 849, 175, 3, 2, 2, 2, 850,
	848, 3, 2, 2, 2, 851, 852, 5, 178, 90, 2, 852, 853, 7, 10, 2, 2, 853, 855,
	3, 2, 2, 2, 854, 851, 3, 2, 2, 2, 854, 855, 3, 2, 2, 2, 855, 856, 3, 2,
	2, 2, 856, 857, 5, 180, 91, 2, 857, 177, 3, 2, 2, 2, 858, 862, 7, 71, 2,
	2, 859, 862, 5, 210, 106, 2, 860, 862, 5, 172, 87, 2, 861, 858, 3, 2, 2,
	2, 861, 859, 3, 2, 2, 2, 861, 860, 3, 2, 2, 2, 862, 179, 3, 2, 2, 2, 863,
	866, 5, 210, 106, 2, 864, 866, 5, 172, 87, 2, 865, 863, 3, 2, 2, 2, 865,
	864, 3, 2, 2, 2, 866, 181, 3, 2, 2, 2, 867, 869, 9, 9, 2, 2, 868, 870,
	7, 71, 2, 2, 869, 868, 3, 2, 2, 2, 869, 870, 3, 2, 2, 2, 870, 872, 3, 2,
	2, 2, 871, 873, 5, 144, 73, 2, 872, 871, 3, 2, 2, 2, 872, 873, 3, 2, 2,
	2, 873, 884, 3, 2, 2, 2, 874, 880, 7, 8, 2, 2, 875, 876, 5, 184, 93, 2,
	876, 877, 5, 216, 109, 2, 877, 879, 3, 2, 2, 2, 878, 875, 3, 2, 2, 2, 879,
	882, 3, 2, 2, 2, 880, 878, 3, 2, 2, 2, 880, 881, 3, 2, 2, 2, 881, 883,
	3, 2, 2, 2, 882, 880, 3, 2, 2, 2, 883, 885, 7, 9, 2, 2, 884, 874, 3, 2,
	2, 2, 884, 885, 3, 2, 2, 2, 885, 183, 3, 2, 2, 2, 886, 887, 6, 93, 4, 2,
	887, 888, 5, 24, 13, 2, 888, 889, 5, 114, 58, 2, 889, 892, 3, 2, 2, 2,
	890, 892, 5, 188, 95, 2, 891, 886, 3, 2, 2, 2, 891, 890, 3, 2, 2, 2, 892,
	894, 3, 2, 2, 2, 893, 895, 7, 81, 2, 2, 894, 893, 3, 2, 2, 2, 894, 895,
	3, 2, 2, 2, 895, 898, 3, 2, 2, 2, 896, 898, 5, 186, 94, 2, 897, 891, 3,
	2, 2, 2, 897, 896, 3, 2, 2, 2, 898, 185, 3, 2, 2, 2, 899, 901, 7, 18, 2,
	2, 900, 899, 3, 2, 2, 2, 900, 901, 3, 2, 2, 2, 901, 902, 3, 2, 2, 2, 902,
	903, 5, 32, 17, 2, 903, 187, 3, 2, 2, 2, 904, 906, 7, 18, 2, 2, 905, 904,
	3, 2, 2, 2, 905, 906, 3, 2, 2, 2, 906, 907, 3, 2, 2, 2, 907, 908, 5, 116,
	59, 2, 908, 189, 3, 2, 2, 2, 909, 910, 7, 55, 2, 2, 910, 911, 5, 34, 18,
	2, 911, 191, 3, 2, 2, 2, 912, 913, 8, 97, 1, 2, 913, 916, 5, 156, 79, 2,
	914, 916, 5, 214, 108, 2, 915, 912, 3, 2, 2, 2, 915, 914, 3, 2, 2, 2, 916,
	921, 3, 2, 2, 2, 917, 918, 12, 3, 2, 2, 918, 920, 5, 194, 98, 2, 919, 917,
	3, 2, 2, 2, 920, 923, 3, 2, 2, 2, 921, 919, 3, 2, 2, 2, 921, 922, 3, 2,
	2, 2, 922, 193, 3, 2, 2, 2, 923, 921, 3, 2, 2, 2, 924, 930, 5, 196, 99,
	2, 925, 930, 5, 198, 100, 2, 926, 930, 5, 200, 101, 2, 927, 930, 5, 202,
	102, 2, 928, 930, 5, 204, 103, 2, 929, 924, 3, 2, 2, 2, 929, 925, 3, 2,
	2, 2, 929, 926, 3, 2, 2, 2, 929, 927, 3, 2, 2, 2, 929, 928, 3, 2, 2, 2,
	930, 195, 3, 2, 2, 2, 931, 932, 7, 11, 2, 2, 932, 933, 7, 71, 2, 2, 933,
	197, 3, 2, 2, 2, 934, 935, 7, 50, 2, 2, 935, 936, 5, 210, 106, 2, 936,
	937, 7, 51, 2, 2, 937, 199, 3, 2, 2, 2, 938, 954, 7, 50, 2, 2, 939, 941,
	5, 210, 106, 2, 940, 939, 3, 2, 2, 2, 940, 941, 3, 2, 2, 2, 941, 942, 3,
	2, 2, 2, 942, 944, 7, 10, 2, 2, 943, 945, 5, 210, 106, 2, 944, 943, 3,
	2, 2, 2, 944, 945, 3, 2, 2, 2, 945, 955, 3, 2, 2, 2, 946, 948, 5, 210,
	106, 2, 947, 946, 3, 2, 2, 2, 947, 948, 3, 2, 2, 2, 948, 949, 3, 2, 2,
	2, 949, 950, 7, 10, 2, 2, 950, 951, 5, 210, 106, 2, 951, 952, 7, 10, 2,
	2, 952, 953, 5, 210, 106, 2, 953, 955, 3, 2, 2, 2, 954, 940, 3, 2, 2, 2,
	954, 947, 3, 2, 2, 2, 955, 956, 3, 2, 2, 2, 956, 957, 7, 51, 2, 2, 957,
	201, 3, 2, 2, 2, 958, 959, 7, 11, 2, 2, 959, 960, 7, 6, 2, 2, 960, 961,
	5, 114, 58, 2, 961, 962, 7, 7, 2, 2, 962, 203, 3, 2, 2, 2, 963, 965, 5,
	144, 73, 2, 964, 963, 3, 2, 2, 2, 964, 965, 3, 2, 2, 2, 965, 966, 3, 2,
	2, 2, 966, 981, 7, 6, 2, 2, 967, 974, 5, 26, 14, 2, 968, 971, 5, 114, 58,
	2, 969, 970, 7, 15, 2, 2, 970, 972, 5, 26, 14, 2, 971, 969, 3, 2, 2, 2,
	971, 972, 3, 2, 2, 2, 972, 974, 3, 2, 2, 2, 973, 967, 3, 2, 2, 2, 973,
	968, 3, 2, 2, 2, 974, 976, 3, 2, 2, 2, 975, 977, 5, 154, 78, 2, 976, 975,
	3, 2, 2, 2, 976, 977, 3, 2, 2, 2, 977, 979, 3, 2, 2, 2, 978, 980, 7, 15,
	2, 2, 979, 978, 3, 2, 2, 2, 979, 980, 3, 2, 2, 2, 980, 982, 3, 2, 2, 2,
	981, 973, 3, 2, 2, 2, 981, 982, 3, 2, 2, 2, 982, 983, 3, 2, 2, 2, 983,
	984, 7, 7, 2, 2, 984, 205, 3, 2, 2, 2, 985, 986, 5, 208, 105, 2, 986, 987,
	7, 11, 2, 2, 987, 988, 7, 71, 2, 2, 988, 207, 3, 2, 2, 2, 989, 1000, 5,
	116, 59, 2, 990, 991, 7, 6, 2, 2, 991, 992, 7, 18, 2, 2, 992, 993, 5, 116,
	59, 2, 993, 994, 7, 7, 2, 2, 994, 1000, 3, 2, 2, 2, 995, 996, 7, 6, 2,
	2, 996, 997, 5, 208, 105, 2, 997, 998, 7, 7, 2, 2, 998, 1000, 3, 2, 2,
	2, 999, 989, 3, 2, 2, 2, 999, 990, 3, 2, 2, 2, 999, 995, 3, 2, 2, 2, 1000,
	209, 3, 2, 2, 2, 1001, 1002, 8, 106, 1, 2, 1002, 1003, 5, 212, 107, 2,
	1003, 1009, 3, 2, 2, 2, 1004, 1005, 12, 4, 2, 2, 1005, 1006, 9, 10, 2,
	2, 1006, 1008, 5, 210, 106, 5, 1007, 1004, 3, 2, 2, 2, 1008, 1011, 3, 2,
	2, 2, 1009, 1007, 3, 2, 2, 2, 1009, 1010, 3, 2, 2, 2, 1010, 211, 3, 2,
	2, 2, 1011, 1009, 3, 2, 2, 2, 1012, 1016, 5, 192, 97, 2, 1013, 1014, 9,
	11, 2, 2, 1014, 1016, 5, 212, 107, 2, 1015, 1012, 3, 2, 2, 2, 1015, 1013,
	3, 2, 2, 2, 1016, 213, 3, 2, 2, 2, 1017, 1018, 5, 114, 58, 2, 1018, 1019,
	7, 6, 2, 2, 1019, 1021, 5, 210, 106, 2, 1020, 1022, 7, 15, 2, 2, 1021,
	1020, 3, 2, 2, 2, 1021, 1022, 3, 2, 2, 2, 1022, 1023, 3, 2, 2, 2, 1023,
	1024, 7, 7, 2, 2, 1024, 215, 3, 2, 2, 2, 1025, 1030, 7, 34, 2, 2, 1026,
	1030, 7, 2, 2, 3, 1027, 1030, 6, 109, 7, 2, 1028, 1030, 6, 109, 8, 2, 1029,
	1025, 3, 2, 2, 2, 1029, 1026, 3, 2, 2, 2, 1029, 1027, 3, 2, 2, 2, 1029,
	1028, 3, 2, 2, 2, 1030, 217, 3, 2, 2, 2, 119, 225, 233, 240, 253, 262,
	266, 271, 278, 283, 293, 297, 301, 311, 319, 330, 334, 338, 346, 352, 357,
	362, 374, 378, 384, 388, 399, 417, 425, 439, 456, 460, 464, 478, 487, 496,
	498, 500, 504, 510, 513, 519, 530, 536, 543, 550, 564, 571, 579, 588, 592,
	595, 603, 611, 617, 621, 625, 629, 637, 645, 649, 659, 675, 683, 687, 707,
	718, 725, 732, 735, 746, 752, 754, 757, 764, 768, 771, 784, 789, 798, 803,
	813, 817, 830, 835, 837, 843, 848, 854, 861, 865, 869, 872, 880, 884, 891,
	894, 897, 900, 905, 915, 921, 929, 940, 944, 947, 954, 964, 971, 973, 976,
	979, 981, 999, 1009, 1015, 1021, 1029,
}
var deserializer = antlr.NewATNDeserializer(nil)
var deserializedATN = deserializer.DeserializeFromUInt16(parserATN)

var literalNames = []string{
	"", "'package'", "'!'", "'import'", "'('", "')'", "'{'", "'}'", "':'",
	"'.'", "'const'", "'='", "'_'", "','", "'type'", "'::'", "'*'", "'var'",
	"'<-'", "'++'", "'--'", "'+'", "'-'", "'|'", "'^'", "'/'", "'%'", "'<<'",
	"'>>'", "'&'", "'&^'", "':='", "';'", "'~'", "'return'", "'break'", "'continue'",
	"'goto'", "'fallthrough'", "'defer'", "'if'", "'=>'", "'else'", "'switch'",
	"'select'", "'for'", "'in'", "'go'", "'['", "']'", "'interface'", "'map'",
	"'chan'", "'fn'", "'<'", "'>'", "'...'", "'true'", "'false'", "'nil'",
	"'@'", "'struct'", "'class'", "'||'", "'&&'", "'=='", "'!='", "'<='", "'>='",
	"", "", "", "'->'",
}
var symbolicNames = []string{
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "IDENTIFIER",
	"KEYWORD", "BINARY_OP", "FUNC", "INT_LIT", "FLOAT_LIT", "IMAGINARY_LIT",
	"RUNE_LIT", "LITTLE_U_VALUE", "BIG_U_VALUE", "STRING_LIT", "WS", "COMMENT",
	"LINE_COMMENT", "TERMINATOR", "ErrorChar",
}

var ruleNames = []string{
	"sourceFile", "interp", "packageClause", "importDecl", "importBody", "importSpec",
	"importPath", "topLevelDecl", "declaration", "constDecl", "constSpec",
	"identifierList", "expressionList", "typeDecl", "typeSpec", "functionDecl",
	"function", "methodDecl", "receiver", "varDecl", "varSpec", "block", "statementList",
	"statement", "simpleStmt", "sendStmt", "incDecStmt", "assignment", "assign_op",
	"shortVarDecl", "emptyStmt", "labeledStmt", "returnStmt", "breakStmt",
	"continueStmt", "gotoStmt", "fallthroughStmt", "deferStmt", "ifStmt", "switchStmt",
	"exprSwitchStmt", "exprCaseClause", "exprSwitchCase", "typeSwitchStmt",
	"typeSwitchGuard", "typeCaseClause", "typeSwitchCase", "typeList", "selectStmt",
	"commClause", "commCase", "recvStmt", "forStmt", "forClause", "rangeClause",
	"goStmt", "type_", "typeName", "typeLit", "arrayType", "arrayLength", "elementType",
	"pointerType", "interfaceType", "sliceType", "mapType", "channelType",
	"channelDecl", "methodSpec", "functionType", "signature", "templateSpec",
	"result", "parameters", "parameterList", "parameterDecl", "restOp", "operand",
	"literal", "basicLit", "operandName", "this_", "qualifiedIdent", "compositeLit",
	"literalType", "literalValue", "elementList", "keyedElement", "key", "element",
	"structType", "fieldDecl", "inlineStructMethod", "anonymousField", "functionLit",
	"primaryExpr", "secondaryExpr", "selector", "index", "slice", "typeAssertion",
	"arguments", "methodExpr", "receiverType", "expression", "unaryExpr", "conversion",
	"eos",
}
var decisionToDFA = make([]*antlr.DFA, len(deserializedATN.DecisionToState))

func init() {
	for index, ds := range deserializedATN.DecisionToState {
		decisionToDFA[index] = antlr.NewDFA(ds, index)
	}
}

type OgParser struct {
	*antlr.BaseParser
}

func NewOgParser(input antlr.TokenStream) *OgParser {
	this := new(OgParser)

	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 = "Og.g4"

	return this
}

/**
 * Returns {@code true} iff on the current index of the parser's
 * token stream a token exists on the {@code HIDDEN} channel which
 * either is a line terminator, or is a multi line comment that
 * contains a line terminator.
 *
 * @return {@code true} iff on the current index of the parser's
 * token stream a token exists on the {@code HIDDEN} channel which
 * either is a line terminator, or is a multi line comment that
 * contains a line terminator.
 */
func (this *OgParser) lineTerminatorAhead() bool {
	// // Get the token ahead of the current index.
	possibleIndexEosToken := this.BaseParser.GetCurrentToken().GetTokenIndex() - 1

	ahead := this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)

	if ahead.GetChannel() != antlr.LexerHidden {
		// We're only interested in tokens on the HIDDEN channel.
		return false
	}

	if ahead.GetTokenType() == OgLexerTERMINATOR {
		// There is definitely a line terminator ahead.
		return true
	}

	if ahead.GetTokenType() == OgLexerWS {
		// Get the token ahead of the current whitespaces.
		possibleIndexEosToken = this.BaseParser.GetCurrentToken().GetTokenIndex() - 2

		ahead = this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)
	}

	// Get the token's text and type.
	text := ahead.GetText()

	t := ahead.GetTokenType()

	// Check if the token is, or contains a line terminator.
	return (t == OgLexerCOMMENT && (strings.Contains(text, "\r") || strings.Contains(text, "\n"))) ||
		(t == OgLexerTERMINATOR)
}

/**
 * Returns {@code true} if no line terminator exists between the specified
 * token offset and the prior one on the {@code HIDDEN} channel.
 *
 * @return {@code true} if no line terminator exists between the specified
 * token offset and the prior one on the {@code HIDDEN} channel.
 */
func (this *OgParser) noTerminatorBetween(tokenOffset int) bool {
	stream := this.BaseParser.GetTokenStream().(*antlr.CommonTokenStream)

	tokens := stream.GetHiddenTokensToLeft(stream.LT(tokenOffset).GetTokenIndex(), antlr.TokenHiddenChannel)

	if tokens == nil {
		return true
	}

	for _, t := range tokens {
		if strings.Contains(t.GetText(), "\n") {
			return false
		}
	}

	return true
}

func (this *OgParser) lookAhead(token int) bool {
	possibleIndexEosToken := this.BaseParser.GetCurrentToken().GetTokenIndex() - 1

	ahead := this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)

	if ahead.GetTokenType() == OgLexerWS {
		possibleIndexEosToken = this.BaseParser.GetCurrentToken().GetTokenIndex()

		ahead = this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)
	}

	fmt.Println("TOKEN AHEAD", ahead)

	return ahead.GetTokenType() == token
}

func (this *OgParser) lookAheadN(token int, n int) bool {
	possibleIndexEosToken := this.BaseParser.GetCurrentToken().GetTokenIndex() - n

	ahead := this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)

	if ahead.GetTokenType() == OgLexerWS {
		// Get the token ahead of the current whitespaces.
		possibleIndexEosToken = this.BaseParser.GetCurrentToken().GetTokenIndex() - (n + 1)

		ahead = this.BaseParser.GetTokenStream().Get(possibleIndexEosToken)
	}

	return ahead.GetTokenType() == token
}

/**
 * Returns {@code true} if no line terminator exists after any encounterd
 * parameters beyond the specified token offset and the next on the
 * {@code HIDDEN} channel.
 *
 * @return {@code true} if no line terminator exists after any encounterd
 * parameters beyond the specified token offset and the next on the
 * {@code HIDDEN} channel.
 */
func (this *OgParser) noTerminatorAfterParams(tokenOffset int) bool {
	stream := this.BaseParser.GetTokenStream()

	leftParams := 1
	rightParams := 0
	var value string

	if stream.LT(tokenOffset).GetText() == "(" {
		// Scan past parameters
		for leftParams != rightParams {
			tokenOffset++

			value = stream.LT(tokenOffset).GetText()

			if value == "(" {
				leftParams++
			} else if value == ")" {
				rightParams++
			}
		}

		tokenOffset++

		return this.noTerminatorBetween(tokenOffset)
	}

	return true
}

// OgParser tokens.
const (
	OgParserEOF            = antlr.TokenEOF
	OgParserT__0           = 1
	OgParserT__1           = 2
	OgParserT__2           = 3
	OgParserT__3           = 4
	OgParserT__4           = 5
	OgParserT__5           = 6
	OgParserT__6           = 7
	OgParserT__7           = 8
	OgParserT__8           = 9
	OgParserT__9           = 10
	OgParserT__10          = 11
	OgParserT__11          = 12
	OgParserT__12          = 13
	OgParserT__13          = 14
	OgParserT__14          = 15
	OgParserT__15          = 16
	OgParserT__16          = 17
	OgParserT__17          = 18
	OgParserT__18          = 19
	OgParserT__19          = 20
	OgParserT__20          = 21
	OgParserT__21          = 22
	OgParserT__22          = 23
	OgParserT__23          = 24
	OgParserT__24          = 25
	OgParserT__25          = 26
	OgParserT__26          = 27
	OgParserT__27          = 28
	OgParserT__28          = 29
	OgParserT__29          = 30
	OgParserT__30          = 31
	OgParserT__31          = 32
	OgParserT__32          = 33
	OgParserT__33          = 34
	OgParserT__34          = 35
	OgParserT__35          = 36
	OgParserT__36          = 37
	OgParserT__37          = 38
	OgParserT__38          = 39
	OgParserT__39          = 40
	OgParserT__40          = 41
	OgParserT__41          = 42
	OgParserT__42          = 43
	OgParserT__43          = 44
	OgParserT__44          = 45
	OgParserT__45          = 46
	OgParserT__46          = 47
	OgParserT__47          = 48
	OgParserT__48          = 49
	OgParserT__49          = 50
	OgParserT__50          = 51
	OgParserT__51          = 52
	OgParserT__52          = 53
	OgParserT__53          = 54
	OgParserT__54          = 55
	OgParserT__55          = 56
	OgParserT__56          = 57
	OgParserT__57          = 58
	OgParserT__58          = 59
	OgParserT__59          = 60
	OgParserT__60          = 61
	OgParserT__61          = 62
	OgParserT__62          = 63
	OgParserT__63          = 64
	OgParserT__64          = 65
	OgParserT__65          = 66
	OgParserT__66          = 67
	OgParserT__67          = 68
	OgParserIDENTIFIER     = 69
	OgParserKEYWORD        = 70
	OgParserBINARY_OP      = 71
	OgParserFUNC           = 72
	OgParserINT_LIT        = 73
	OgParserFLOAT_LIT      = 74
	OgParserIMAGINARY_LIT  = 75
	OgParserRUNE_LIT       = 76
	OgParserLITTLE_U_VALUE = 77
	OgParserBIG_U_VALUE    = 78
	OgParserSTRING_LIT     = 79
	OgParserWS             = 80
	OgParserCOMMENT        = 81
	OgParserLINE_COMMENT   = 82
	OgParserTERMINATOR     = 83
	OgParserErrorChar      = 84
)

// OgParser rules.
const (
	OgParserRULE_sourceFile         = 0
	OgParserRULE_interp             = 1
	OgParserRULE_packageClause      = 2
	OgParserRULE_importDecl         = 3
	OgParserRULE_importBody         = 4
	OgParserRULE_importSpec         = 5
	OgParserRULE_importPath         = 6
	OgParserRULE_topLevelDecl       = 7
	OgParserRULE_declaration        = 8
	OgParserRULE_constDecl          = 9
	OgParserRULE_constSpec          = 10
	OgParserRULE_identifierList     = 11
	OgParserRULE_expressionList     = 12
	OgParserRULE_typeDecl           = 13
	OgParserRULE_typeSpec           = 14
	OgParserRULE_functionDecl       = 15
	OgParserRULE_function           = 16
	OgParserRULE_methodDecl         = 17
	OgParserRULE_receiver           = 18
	OgParserRULE_varDecl            = 19
	OgParserRULE_varSpec            = 20
	OgParserRULE_block              = 21
	OgParserRULE_statementList      = 22
	OgParserRULE_statement          = 23
	OgParserRULE_simpleStmt         = 24
	OgParserRULE_sendStmt           = 25
	OgParserRULE_incDecStmt         = 26
	OgParserRULE_assignment         = 27
	OgParserRULE_assign_op          = 28
	OgParserRULE_shortVarDecl       = 29
	OgParserRULE_emptyStmt          = 30
	OgParserRULE_labeledStmt        = 31
	OgParserRULE_returnStmt         = 32
	OgParserRULE_breakStmt          = 33
	OgParserRULE_continueStmt       = 34
	OgParserRULE_gotoStmt           = 35
	OgParserRULE_fallthroughStmt    = 36
	OgParserRULE_deferStmt          = 37
	OgParserRULE_ifStmt             = 38
	OgParserRULE_switchStmt         = 39
	OgParserRULE_exprSwitchStmt     = 40
	OgParserRULE_exprCaseClause     = 41
	OgParserRULE_exprSwitchCase     = 42
	OgParserRULE_typeSwitchStmt     = 43
	OgParserRULE_typeSwitchGuard    = 44
	OgParserRULE_typeCaseClause     = 45
	OgParserRULE_typeSwitchCase     = 46
	OgParserRULE_typeList           = 47
	OgParserRULE_selectStmt         = 48
	OgParserRULE_commClause         = 49
	OgParserRULE_commCase           = 50
	OgParserRULE_recvStmt           = 51
	OgParserRULE_forStmt            = 52
	OgParserRULE_forClause          = 53
	OgParserRULE_rangeClause        = 54
	OgParserRULE_goStmt             = 55
	OgParserRULE_type_              = 56
	OgParserRULE_typeName           = 57
	OgParserRULE_typeLit            = 58
	OgParserRULE_arrayType          = 59
	OgParserRULE_arrayLength        = 60
	OgParserRULE_elementType        = 61
	OgParserRULE_pointerType        = 62
	OgParserRULE_interfaceType      = 63
	OgParserRULE_sliceType          = 64
	OgParserRULE_mapType            = 65
	OgParserRULE_channelType        = 66
	OgParserRULE_channelDecl        = 67
	OgParserRULE_methodSpec         = 68
	OgParserRULE_functionType       = 69
	OgParserRULE_signature          = 70
	OgParserRULE_templateSpec       = 71
	OgParserRULE_result             = 72
	OgParserRULE_parameters         = 73
	OgParserRULE_parameterList      = 74
	OgParserRULE_parameterDecl      = 75
	OgParserRULE_restOp             = 76
	OgParserRULE_operand            = 77
	OgParserRULE_literal            = 78
	OgParserRULE_basicLit           = 79
	OgParserRULE_operandName        = 80
	OgParserRULE_this_              = 81
	OgParserRULE_qualifiedIdent     = 82
	OgParserRULE_compositeLit       = 83
	OgParserRULE_literalType        = 84
	OgParserRULE_literalValue       = 85
	OgParserRULE_elementList        = 86
	OgParserRULE_keyedElement       = 87
	OgParserRULE_key                = 88
	OgParserRULE_element            = 89
	OgParserRULE_structType         = 90
	OgParserRULE_fieldDecl          = 91
	OgParserRULE_inlineStructMethod = 92
	OgParserRULE_anonymousField     = 93
	OgParserRULE_functionLit        = 94
	OgParserRULE_primaryExpr        = 95
	OgParserRULE_secondaryExpr      = 96
	OgParserRULE_selector           = 97
	OgParserRULE_index              = 98
	OgParserRULE_slice              = 99
	OgParserRULE_typeAssertion      = 100
	OgParserRULE_arguments          = 101
	OgParserRULE_methodExpr         = 102
	OgParserRULE_receiverType       = 103
	OgParserRULE_expression         = 104
	OgParserRULE_unaryExpr          = 105
	OgParserRULE_conversion         = 106
	OgParserRULE_eos                = 107
)

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

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

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

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

func NewEmptySourceFileContext() *SourceFileContext {
	var p = new(SourceFileContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_sourceFile
	return p
}

func (*SourceFileContext) IsSourceFileContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_sourceFile

	return p
}

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

func (s *SourceFileContext) PackageClause() IPackageClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageClauseContext)
}

func (s *SourceFileContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *SourceFileContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *SourceFileContext) EOF() antlr.TerminalNode {
	return s.GetToken(OgParserEOF, 0)
}

func (s *SourceFileContext) AllImportDecl() []IImportDeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportDeclContext)(nil)).Elem())
	var tst = make([]IImportDeclContext, len(ts))

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

	return tst
}

func (s *SourceFileContext) ImportDecl(i int) IImportDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportDeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IImportDeclContext)
}

func (s *SourceFileContext) AllTopLevelDecl() []ITopLevelDeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITopLevelDeclContext)(nil)).Elem())
	var tst = make([]ITopLevelDeclContext, len(ts))

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

	return tst
}

func (s *SourceFileContext) TopLevelDecl(i int) ITopLevelDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITopLevelDeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITopLevelDeclContext)
}

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

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

func (s *SourceFileContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSourceFile(s)
	}
}

func (s *SourceFileContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSourceFile(s)
	}
}

func (s *SourceFileContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SourceFileVisitor:
		return t.VisitSourceFile(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SourceFile() (localctx ISourceFileContext) {
	localctx = NewSourceFileContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, OgParserRULE_sourceFile)
	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(216)
		p.PackageClause()
	}
	{
		p.SetState(217)
		p.Eos()
	}
	p.SetState(223)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == OgParserT__2 {
		{
			p.SetState(218)
			p.ImportDecl()
		}
		{
			p.SetState(219)
			p.Eos()
		}

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

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__9)|(1<<OgParserT__13)|(1<<OgParserT__16))) != 0) || (((_la-50)&-(0x1f+1)) == 0 && ((1<<uint((_la-50)))&((1<<(OgParserT__49-50))|(1<<(OgParserT__60-50))|(1<<(OgParserT__61-50))|(1<<(OgParserIDENTIFIER-50)))) != 0) {
		{
			p.SetState(226)
			p.TopLevelDecl()
		}
		{
			p.SetState(227)
			p.Eos()
		}

		p.SetState(233)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(234)
		p.Match(OgParserEOF)
	}

	return localctx
}

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

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

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

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

func NewEmptyInterpContext() *InterpContext {
	var p = new(InterpContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_interp
	return p
}

func (*InterpContext) IsInterpContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_interp

	return p
}

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

func (s *InterpContext) EOF() antlr.TerminalNode {
	return s.GetToken(OgParserEOF, 0)
}

func (s *InterpContext) TopLevelDecl() ITopLevelDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITopLevelDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITopLevelDeclContext)
}

func (s *InterpContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *InterpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterInterp(s)
	}
}

func (s *InterpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitInterp(s)
	}
}

func (s *InterpContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case InterpVisitor:
		return t.VisitInterp(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Interp() (localctx IInterpContext) {
	localctx = NewInterpContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, OgParserRULE_interp)

	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(238)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(236)
			p.TopLevelDecl()
		}

	case 2:
		{
			p.SetState(237)
			p.Statement()
		}

	}
	{
		p.SetState(240)
		p.Match(OgParserEOF)
	}

	return localctx
}

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

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

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

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

func NewEmptyPackageClauseContext() *PackageClauseContext {
	var p = new(PackageClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_packageClause
	return p
}

func (*PackageClauseContext) IsPackageClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_packageClause

	return p
}

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

func (s *PackageClauseContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *PackageClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterPackageClause(s)
	}
}

func (s *PackageClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitPackageClause(s)
	}
}

func (s *PackageClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case PackageClauseVisitor:
		return t.VisitPackageClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) PackageClause() (localctx IPackageClauseContext) {
	localctx = NewPackageClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, OgParserRULE_packageClause)
	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(242)
	_la = p.GetTokenStream().LA(1)

	if !(_la == OgParserT__0 || _la == OgParserT__1) {
		p.GetErrorHandler().RecoverInline(p)
	} else {
		p.GetErrorHandler().ReportMatch(p)
		p.Consume()
	}
	{
		p.SetState(243)
		p.Match(OgParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyImportDeclContext() *ImportDeclContext {
	var p = new(ImportDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_importDecl
	return p
}

func (*ImportDeclContext) IsImportDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_importDecl

	return p
}

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

func (s *ImportDeclContext) ImportBody() IImportBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportBodyContext)
}

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

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

func (s *ImportDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterImportDecl(s)
	}
}

func (s *ImportDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitImportDecl(s)
	}
}

func (s *ImportDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ImportDeclVisitor:
		return t.VisitImportDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ImportDecl() (localctx IImportDeclContext) {
	localctx = NewImportDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, OgParserRULE_importDecl)

	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(245)
		p.Match(OgParserT__2)
	}
	p.SetState(251)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__5, OgParserIDENTIFIER, OgParserSTRING_LIT:
		{
			p.SetState(246)
			p.ImportBody()
		}

	case OgParserT__3:
		{
			p.SetState(247)
			p.Match(OgParserT__3)
		}
		{
			p.SetState(248)
			p.ImportBody()
		}
		{
			p.SetState(249)
			p.Match(OgParserT__4)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyImportBodyContext() *ImportBodyContext {
	var p = new(ImportBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_importBody
	return p
}

func (*ImportBodyContext) IsImportBodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_importBody

	return p
}

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

func (s *ImportBodyContext) AllImportSpec() []IImportSpecContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportSpecContext)(nil)).Elem())
	var tst = make([]IImportSpecContext, len(ts))

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

	return tst
}

func (s *ImportBodyContext) ImportSpec(i int) IImportSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportSpecContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IImportSpecContext)
}

func (s *ImportBodyContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *ImportBodyContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

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

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

func (s *ImportBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterImportBody(s)
	}
}

func (s *ImportBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitImportBody(s)
	}
}

func (s *ImportBodyContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ImportBodyVisitor:
		return t.VisitImportBody(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ImportBody() (localctx IImportBodyContext) {
	localctx = NewImportBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, OgParserRULE_importBody)
	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(264)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserIDENTIFIER, OgParserSTRING_LIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(253)
			p.ImportSpec()
		}

	case OgParserT__5:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(254)
			p.Match(OgParserT__5)
		}
		p.SetState(260)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == OgParserIDENTIFIER || _la == OgParserSTRING_LIT {
			{
				p.SetState(255)
				p.ImportSpec()
			}
			{
				p.SetState(256)
				p.Eos()
			}

			p.SetState(262)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(263)
			p.Match(OgParserT__6)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyImportSpecContext() *ImportSpecContext {
	var p = new(ImportSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_importSpec
	return p
}

func (*ImportSpecContext) IsImportSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_importSpec

	return p
}

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

func (s *ImportSpecContext) ImportPath() IImportPathContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportPathContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportPathContext)
}

func (s *ImportSpecContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *ImportSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterImportSpec(s)
	}
}

func (s *ImportSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitImportSpec(s)
	}
}

func (s *ImportSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ImportSpecVisitor:
		return t.VisitImportSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ImportSpec() (localctx IImportSpecContext) {
	localctx = NewImportSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, OgParserRULE_importSpec)
	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(266)
		p.ImportPath()
	}
	p.SetState(269)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(267)
			p.Match(OgParserT__7)
		}
		p.SetState(268)
		_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyImportPathContext() *ImportPathContext {
	var p = new(ImportPathContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_importPath
	return p
}

func (*ImportPathContext) IsImportPathContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_importPath

	return p
}

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

func (s *ImportPathContext) STRING_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserSTRING_LIT, 0)
}

func (s *ImportPathContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *ImportPathContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterImportPath(s)
	}
}

func (s *ImportPathContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitImportPath(s)
	}
}

func (s *ImportPathContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ImportPathVisitor:
		return t.VisitImportPath(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ImportPath() (localctx IImportPathContext) {
	localctx = NewImportPathContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, OgParserRULE_importPath)
	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(271)
	_la = p.GetTokenStream().LA(1)

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

	return localctx
}

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

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

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

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

func NewEmptyTopLevelDeclContext() *TopLevelDeclContext {
	var p = new(TopLevelDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_topLevelDecl
	return p
}

func (*TopLevelDeclContext) IsTopLevelDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_topLevelDecl

	return p
}

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

func (s *TopLevelDeclContext) Declaration() IDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *TopLevelDeclContext) FunctionDecl() IFunctionDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionDeclContext)
}

func (s *TopLevelDeclContext) MethodDecl() IMethodDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodDeclContext)
}

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

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

func (s *TopLevelDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTopLevelDecl(s)
	}
}

func (s *TopLevelDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTopLevelDecl(s)
	}
}

func (s *TopLevelDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TopLevelDeclVisitor:
		return t.VisitTopLevelDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TopLevelDecl() (localctx ITopLevelDeclContext) {
	localctx = NewTopLevelDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, OgParserRULE_topLevelDecl)

	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(276)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(273)
			p.Declaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(274)
			p.FunctionDecl()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(275)
			p.MethodDecl()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDeclarationContext() *DeclarationContext {
	var p = new(DeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_declaration
	return p
}

func (*DeclarationContext) IsDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_declaration

	return p
}

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

func (s *DeclarationContext) ConstDecl() IConstDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstDeclContext)
}

func (s *DeclarationContext) TypeDecl() ITypeDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeDeclContext)
}

func (s *DeclarationContext) VarDecl() IVarDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVarDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVarDeclContext)
}

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

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

func (s *DeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterDeclaration(s)
	}
}

func (s *DeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitDeclaration(s)
	}
}

func (s *DeclarationContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case DeclarationVisitor:
		return t.VisitDeclaration(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Declaration() (localctx IDeclarationContext) {
	localctx = NewDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, OgParserRULE_declaration)

	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(281)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__9:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(278)
			p.ConstDecl()
		}

	case OgParserT__13, OgParserT__49, OgParserT__60, OgParserT__61:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(279)
			p.TypeDecl()
		}

	case OgParserT__16:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(280)
			p.VarDecl()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyConstDeclContext() *ConstDeclContext {
	var p = new(ConstDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_constDecl
	return p
}

func (*ConstDeclContext) IsConstDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_constDecl

	return p
}

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

func (s *ConstDeclContext) AllConstSpec() []IConstSpecContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstSpecContext)(nil)).Elem())
	var tst = make([]IConstSpecContext, len(ts))

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

	return tst
}

func (s *ConstDeclContext) ConstSpec(i int) IConstSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstSpecContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstSpecContext)
}

func (s *ConstDeclContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *ConstDeclContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

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

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

func (s *ConstDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterConstDecl(s)
	}
}

func (s *ConstDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitConstDecl(s)
	}
}

func (s *ConstDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ConstDeclVisitor:
		return t.VisitConstDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ConstDecl() (localctx IConstDeclContext) {
	localctx = NewConstDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, OgParserRULE_constDecl)
	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(283)
		p.Match(OgParserT__9)
	}
	p.SetState(295)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__11, OgParserIDENTIFIER:
		{
			p.SetState(284)
			p.ConstSpec()
		}

	case OgParserT__3:
		{
			p.SetState(285)
			p.Match(OgParserT__3)
		}
		p.SetState(291)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == OgParserT__11 || _la == OgParserIDENTIFIER {
			{
				p.SetState(286)
				p.ConstSpec()
			}
			{
				p.SetState(287)
				p.Eos()
			}

			p.SetState(293)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(294)
			p.Match(OgParserT__4)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyConstSpecContext() *ConstSpecContext {
	var p = new(ConstSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_constSpec
	return p
}

func (*ConstSpecContext) IsConstSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_constSpec

	return p
}

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

func (s *ConstSpecContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *ConstSpecContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *ConstSpecContext) 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 *ConstSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *ConstSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterConstSpec(s)
	}
}

func (s *ConstSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitConstSpec(s)
	}
}

func (s *ConstSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ConstSpecVisitor:
		return t.VisitConstSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ConstSpec() (localctx IConstSpecContext) {
	localctx = NewConstSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, OgParserRULE_constSpec)
	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(297)
		p.IdentifierList()
	}

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

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48)))) != 0) {
		{
			p.SetState(298)
			p.Type_()
		}

	}
	{
		p.SetState(301)
		p.Match(OgParserT__10)
	}
	{
		p.SetState(302)
		p.ExpressionList()
	}

	return localctx
}

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

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

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

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

func NewEmptyIdentifierListContext() *IdentifierListContext {
	var p = new(IdentifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_identifierList
	return p
}

func (*IdentifierListContext) IsIdentifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_identifierList

	return p
}

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

func (s *IdentifierListContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(OgParserIDENTIFIER)
}

func (s *IdentifierListContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, i)
}

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

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

func (s *IdentifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterIdentifierList(s)
	}
}

func (s *IdentifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitIdentifierList(s)
	}
}

func (s *IdentifierListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case IdentifierListVisitor:
		return t.VisitIdentifierList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) IdentifierList() (localctx IIdentifierListContext) {
	localctx = NewIdentifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, OgParserRULE_identifierList)
	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(304)
	_la = p.GetTokenStream().LA(1)

	if !(_la == OgParserT__11 || _la == OgParserIDENTIFIER) {
		p.GetErrorHandler().RecoverInline(p)
	} else {
		p.GetErrorHandler().ReportMatch(p)
		p.Consume()
	}
	p.SetState(309)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == OgParserT__12 {
		{
			p.SetState(305)
			p.Match(OgParserT__12)
		}
		p.SetState(306)
		_la = p.GetTokenStream().LA(1)

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

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

	return localctx
}

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

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

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

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

func NewEmptyExpressionListContext() *ExpressionListContext {
	var p = new(ExpressionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_expressionList
	return p
}

func (*ExpressionListContext) IsExpressionListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_expressionList

	return p
}

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

func (s *ExpressionListContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

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

	return tst
}

func (s *ExpressionListContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterExpressionList(s)
	}
}

func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitExpressionList(s)
	}
}

func (s *ExpressionListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ExpressionListVisitor:
		return t.VisitExpressionList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ExpressionList() (localctx IExpressionListContext) {
	localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, OgParserRULE_expressionList)

	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(312)
		p.expression(0)
	}
	p.SetState(317)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(313)
				p.Match(OgParserT__12)
			}
			{
				p.SetState(314)
				p.expression(0)
			}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeDeclContext() *TypeDeclContext {
	var p = new(TypeDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeDecl
	return p
}

func (*TypeDeclContext) IsTypeDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeDecl

	return p
}

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

func (s *TypeDeclContext) AllTypeSpec() []ITypeSpecContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeSpecContext)(nil)).Elem())
	var tst = make([]ITypeSpecContext, len(ts))

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

	return tst
}

func (s *TypeDeclContext) TypeSpec(i int) ITypeSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeSpecContext)
}

func (s *TypeDeclContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *TypeDeclContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *TypeDeclContext) StructType() IStructTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructTypeContext)
}

func (s *TypeDeclContext) InterfaceType() IInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeContext)
}

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

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

func (s *TypeDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeDecl(s)
	}
}

func (s *TypeDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeDecl(s)
	}
}

func (s *TypeDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeDeclVisitor:
		return t.VisitTypeDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeDecl() (localctx ITypeDeclContext) {
	localctx = NewTypeDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, OgParserRULE_typeDecl)
	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(336)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__13:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(320)
			p.Match(OgParserT__13)
		}
		p.SetState(332)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case OgParserIDENTIFIER:
			{
				p.SetState(321)
				p.TypeSpec()
			}

		case OgParserT__3:
			{
				p.SetState(322)
				p.Match(OgParserT__3)
			}
			p.SetState(328)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == OgParserIDENTIFIER {
				{
					p.SetState(323)
					p.TypeSpec()
				}
				{
					p.SetState(324)
					p.Eos()
				}

				p.SetState(330)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(331)
				p.Match(OgParserT__4)
			}

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

	case OgParserT__60, OgParserT__61:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(334)
			p.StructType()
		}

	case OgParserT__49:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(335)
			p.InterfaceType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeSpecContext() *TypeSpecContext {
	var p = new(TypeSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeSpec
	return p
}

func (*TypeSpecContext) IsTypeSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeSpec

	return p
}

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

func (s *TypeSpecContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *TypeSpecContext) 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 *TypeSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *TypeSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeSpec(s)
	}
}

func (s *TypeSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeSpec(s)
	}
}

func (s *TypeSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeSpecVisitor:
		return t.VisitTypeSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeSpec() (localctx ITypeSpecContext) {
	localctx = NewTypeSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, OgParserRULE_typeSpec)

	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(338)
		p.Match(OgParserIDENTIFIER)
	}
	{
		p.SetState(339)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionDeclContext() *FunctionDeclContext {
	var p = new(FunctionDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_functionDecl
	return p
}

func (*FunctionDeclContext) IsFunctionDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_functionDecl

	return p
}

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

func (s *FunctionDeclContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *FunctionDeclContext) Function() IFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionContext)
}

func (s *FunctionDeclContext) Signature() ISignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISignatureContext)
}

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

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

func (s *FunctionDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFunctionDecl(s)
	}
}

func (s *FunctionDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFunctionDecl(s)
	}
}

func (s *FunctionDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FunctionDeclVisitor:
		return t.VisitFunctionDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) FunctionDecl() (localctx IFunctionDeclContext) {
	localctx = NewFunctionDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, OgParserRULE_functionDecl)

	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(341)
		p.Match(OgParserIDENTIFIER)
	}
	p.SetState(344)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(342)
			p.Function()
		}

	case 2:
		{
			p.SetState(343)
			p.Signature()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionContext() *FunctionContext {
	var p = new(FunctionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_function
	return p
}

func (*FunctionContext) IsFunctionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_function

	return p
}

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

func (s *FunctionContext) Signature() ISignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISignatureContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *FunctionContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *FunctionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFunction(s)
	}
}

func (s *FunctionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFunction(s)
	}
}

func (s *FunctionContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FunctionVisitor:
		return t.VisitFunction(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Function() (localctx IFunctionContext) {
	localctx = NewFunctionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, OgParserRULE_function)

	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(346)
		p.Signature()
	}
	{
		p.SetState(347)
		p.Match(OgParserFUNC)
	}
	p.SetState(350)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(348)
			p.Block()
		}

	case 2:
		{
			p.SetState(349)
			p.Statement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMethodDeclContext() *MethodDeclContext {
	var p = new(MethodDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_methodDecl
	return p
}

func (*MethodDeclContext) IsMethodDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_methodDecl

	return p
}

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

func (s *MethodDeclContext) Receiver() IReceiverContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverContext)
}

func (s *MethodDeclContext) Function() IFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionContext)
}

func (s *MethodDeclContext) Signature() ISignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISignatureContext)
}

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

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

func (s *MethodDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterMethodDecl(s)
	}
}

func (s *MethodDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitMethodDecl(s)
	}
}

func (s *MethodDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case MethodDeclVisitor:
		return t.VisitMethodDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) MethodDecl() (localctx IMethodDeclContext) {
	localctx = NewMethodDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, OgParserRULE_methodDecl)

	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(352)
		p.Receiver()
	}
	p.SetState(355)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(353)
			p.Function()
		}

	case 2:
		{
			p.SetState(354)
			p.Signature()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyReceiverContext() *ReceiverContext {
	var p = new(ReceiverContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_receiver
	return p
}

func (*ReceiverContext) IsReceiverContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_receiver

	return p
}

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

func (s *ReceiverContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(OgParserIDENTIFIER)
}

func (s *ReceiverContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, i)
}

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

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

func (s *ReceiverContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterReceiver(s)
	}
}

func (s *ReceiverContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitReceiver(s)
	}
}

func (s *ReceiverContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ReceiverVisitor:
		return t.VisitReceiver(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Receiver() (localctx IReceiverContext) {
	localctx = NewReceiverContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, OgParserRULE_receiver)
	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(357)
		p.Match(OgParserIDENTIFIER)
	}
	{
		p.SetState(358)
		p.Match(OgParserT__14)
	}
	p.SetState(360)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__15 {
		{
			p.SetState(359)
			p.Match(OgParserT__15)
		}

	}
	{
		p.SetState(362)
		p.Match(OgParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyVarDeclContext() *VarDeclContext {
	var p = new(VarDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_varDecl
	return p
}

func (*VarDeclContext) IsVarDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_varDecl

	return p
}

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

func (s *VarDeclContext) AllVarSpec() []IVarSpecContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVarSpecContext)(nil)).Elem())
	var tst = make([]IVarSpecContext, len(ts))

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

	return tst
}

func (s *VarDeclContext) VarSpec(i int) IVarSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVarSpecContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVarSpecContext)
}

func (s *VarDeclContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *VarDeclContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

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

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

func (s *VarDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterVarDecl(s)
	}
}

func (s *VarDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitVarDecl(s)
	}
}

func (s *VarDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case VarDeclVisitor:
		return t.VisitVarDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) VarDecl() (localctx IVarDeclContext) {
	localctx = NewVarDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, OgParserRULE_varDecl)
	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(364)
		p.Match(OgParserT__16)
	}
	p.SetState(376)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__11, OgParserIDENTIFIER:
		{
			p.SetState(365)
			p.VarSpec()
		}

	case OgParserT__3:
		{
			p.SetState(366)
			p.Match(OgParserT__3)
		}
		p.SetState(372)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == OgParserT__11 || _la == OgParserIDENTIFIER {
			{
				p.SetState(367)
				p.VarSpec()
			}
			{
				p.SetState(368)
				p.Eos()
			}

			p.SetState(374)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(375)
			p.Match(OgParserT__4)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyVarSpecContext() *VarSpecContext {
	var p = new(VarSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_varSpec
	return p
}

func (*VarSpecContext) IsVarSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_varSpec

	return p
}

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

func (s *VarSpecContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *VarSpecContext) 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 *VarSpecContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *VarSpecContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *VarSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterVarSpec(s)
	}
}

func (s *VarSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitVarSpec(s)
	}
}

func (s *VarSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case VarSpecVisitor:
		return t.VisitVarSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) VarSpec() (localctx IVarSpecContext) {
	localctx = NewVarSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, OgParserRULE_varSpec)

	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(378)
		p.IdentifierList()
	}
	p.SetState(386)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__3, OgParserT__15, OgParserT__17, OgParserT__47, OgParserT__49, OgParserT__50, OgParserT__51, OgParserT__52, OgParserT__59, OgParserT__60, OgParserT__61, OgParserIDENTIFIER:
		{
			p.SetState(379)
			p.Type_()
		}
		p.SetState(382)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(380)
				p.Match(OgParserT__10)
			}
			{
				p.SetState(381)
				p.Statement()
			}

		}

	case OgParserT__10:
		{
			p.SetState(384)
			p.Match(OgParserT__10)
		}
		{
			p.SetState(385)
			p.ExpressionList()
		}

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

	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 = OgParserRULE_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 = OgParserRULE_block

	return p
}

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

func (s *BlockContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

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.(OgListener); ok {
		listenerT.EnterBlock(s)
	}
}

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

func (s *BlockContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case BlockVisitor:
		return t.VisitBlock(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Block() (localctx IBlockContext) {
	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, OgParserRULE_block)

	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(388)
		p.Match(OgParserT__5)
	}
	{
		p.SetState(389)
		p.StatementList()
	}
	{
		p.SetState(390)
		p.Match(OgParserT__6)
	}

	return localctx
}

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

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

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

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

func NewEmptyStatementListContext() *StatementListContext {
	var p = new(StatementListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_statementList
	return p
}

func (*StatementListContext) IsStatementListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_statementList

	return p
}

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

func (s *StatementListContext) AllStatement() []IStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementContext)(nil)).Elem())
	var tst = make([]IStatementContext, len(ts))

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

	return tst
}

func (s *StatementListContext) Statement(i int) IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *StatementListContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *StatementListContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

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

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

func (s *StatementListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterStatementList(s)
	}
}

func (s *StatementListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitStatementList(s)
	}
}

func (s *StatementListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case StatementListVisitor:
		return t.VisitStatementList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) StatementList() (localctx IStatementListContext) {
	localctx = NewStatementListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, OgParserRULE_statementList)

	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(397)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(392)
				p.Statement()
			}
			{
				p.SetState(393)
				p.Eos()
			}

		}
		p.SetState(399)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyStatementContext() *StatementContext {
	var p = new(StatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_statement
	return p
}

func (*StatementContext) IsStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_statement

	return p
}

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

func (s *StatementContext) ForStmt() IForStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForStmtContext)
}

func (s *StatementContext) SimpleStmt() ISimpleStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleStmtContext)
}

func (s *StatementContext) GoStmt() IGoStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGoStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGoStmtContext)
}

func (s *StatementContext) ReturnStmt() IReturnStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnStmtContext)
}

func (s *StatementContext) BreakStmt() IBreakStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBreakStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBreakStmtContext)
}

func (s *StatementContext) ContinueStmt() IContinueStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IContinueStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IContinueStmtContext)
}

func (s *StatementContext) GotoStmt() IGotoStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGotoStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGotoStmtContext)
}

func (s *StatementContext) FallthroughStmt() IFallthroughStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFallthroughStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFallthroughStmtContext)
}

func (s *StatementContext) IfStmt() IIfStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfStmtContext)
}

func (s *StatementContext) SwitchStmt() ISwitchStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchStmtContext)
}

func (s *StatementContext) SelectStmt() ISelectStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelectStmtContext)
}

func (s *StatementContext) DeferStmt() IDeferStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeferStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeferStmtContext)
}

func (s *StatementContext) LabeledStmt() ILabeledStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILabeledStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILabeledStmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *StatementContext) Declaration() IDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

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

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

func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterStatement(s)
	}
}

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitStatement(s)
	}
}

func (s *StatementContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case StatementVisitor:
		return t.VisitStatement(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Statement() (localctx IStatementContext) {
	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, OgParserRULE_statement)

	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(415)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(400)
			p.ForStmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(401)
			p.SimpleStmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(402)
			p.GoStmt()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(403)
			p.ReturnStmt()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(404)
			p.BreakStmt()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(405)
			p.ContinueStmt()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(406)
			p.GotoStmt()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(407)
			p.FallthroughStmt()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(408)
			p.IfStmt()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(409)
			p.SwitchStmt()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(410)
			p.SelectStmt()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(411)
			p.DeferStmt()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(412)
			p.LabeledStmt()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(413)
			p.Block()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(414)
			p.Declaration()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySimpleStmtContext() *SimpleStmtContext {
	var p = new(SimpleStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_simpleStmt
	return p
}

func (*SimpleStmtContext) IsSimpleStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_simpleStmt

	return p
}

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

func (s *SimpleStmtContext) SendStmt() ISendStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISendStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISendStmtContext)
}

func (s *SimpleStmtContext) IncDecStmt() IIncDecStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIncDecStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIncDecStmtContext)
}

func (s *SimpleStmtContext) ShortVarDecl() IShortVarDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShortVarDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShortVarDeclContext)
}

func (s *SimpleStmtContext) Assignment() IAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentContext)
}

func (s *SimpleStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SimpleStmtContext) EmptyStmt() IEmptyStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEmptyStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEmptyStmtContext)
}

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

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

func (s *SimpleStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSimpleStmt(s)
	}
}

func (s *SimpleStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSimpleStmt(s)
	}
}

func (s *SimpleStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SimpleStmtVisitor:
		return t.VisitSimpleStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SimpleStmt() (localctx ISimpleStmtContext) {
	localctx = NewSimpleStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, OgParserRULE_simpleStmt)

	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(423)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(417)
			p.SendStmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(418)
			p.IncDecStmt()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(419)
			p.ShortVarDecl()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(420)
			p.Assignment()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(421)
			p.expression(0)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(422)
			p.EmptyStmt()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySendStmtContext() *SendStmtContext {
	var p = new(SendStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_sendStmt
	return p
}

func (*SendStmtContext) IsSendStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_sendStmt

	return p
}

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

func (s *SendStmtContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

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

	return tst
}

func (s *SendStmtContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *SendStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSendStmt(s)
	}
}

func (s *SendStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSendStmt(s)
	}
}

func (s *SendStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SendStmtVisitor:
		return t.VisitSendStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SendStmt() (localctx ISendStmtContext) {
	localctx = NewSendStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, OgParserRULE_sendStmt)

	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(425)
		p.expression(0)
	}
	{
		p.SetState(426)
		p.Match(OgParserT__17)
	}
	{
		p.SetState(427)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyIncDecStmtContext() *IncDecStmtContext {
	var p = new(IncDecStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_incDecStmt
	return p
}

func (*IncDecStmtContext) IsIncDecStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_incDecStmt

	return p
}

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

func (s *IncDecStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *IncDecStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterIncDecStmt(s)
	}
}

func (s *IncDecStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitIncDecStmt(s)
	}
}

func (s *IncDecStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case IncDecStmtVisitor:
		return t.VisitIncDecStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) IncDecStmt() (localctx IIncDecStmtContext) {
	localctx = NewIncDecStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, OgParserRULE_incDecStmt)
	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(429)
		p.expression(0)
	}
	p.SetState(430)
	_la = p.GetTokenStream().LA(1)

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

	return localctx
}

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

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

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

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

func NewEmptyAssignmentContext() *AssignmentContext {
	var p = new(AssignmentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_assignment
	return p
}

func (*AssignmentContext) IsAssignmentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_assignment

	return p
}

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

func (s *AssignmentContext) AllExpressionList() []IExpressionListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionListContext)(nil)).Elem())
	var tst = make([]IExpressionListContext, len(ts))

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

	return tst
}

func (s *AssignmentContext) ExpressionList(i int) IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *AssignmentContext) Assign_op() IAssign_opContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssign_opContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssign_opContext)
}

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

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

func (s *AssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterAssignment(s)
	}
}

func (s *AssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitAssignment(s)
	}
}

func (s *AssignmentContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case AssignmentVisitor:
		return t.VisitAssignment(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Assignment() (localctx IAssignmentContext) {
	localctx = NewAssignmentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, OgParserRULE_assignment)

	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(432)
		p.ExpressionList()
	}
	{
		p.SetState(433)
		p.Assign_op()
	}
	{
		p.SetState(434)
		p.ExpressionList()
	}

	return localctx
}

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

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

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

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

func NewEmptyAssign_opContext() *Assign_opContext {
	var p = new(Assign_opContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_assign_op
	return p
}

func (*Assign_opContext) IsAssign_opContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_assign_op

	return p
}

func (s *Assign_opContext) GetParser() antlr.Parser { return s.parser }
func (s *Assign_opContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Assign_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterAssign_op(s)
	}
}

func (s *Assign_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitAssign_op(s)
	}
}

func (s *Assign_opContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case Assign_opVisitor:
		return t.VisitAssign_op(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Assign_op() (localctx IAssign_opContext) {
	localctx = NewAssign_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, OgParserRULE_assign_op)
	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(437)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__15)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__22)|(1<<OgParserT__23)|(1<<OgParserT__24)|(1<<OgParserT__25)|(1<<OgParserT__26)|(1<<OgParserT__27)|(1<<OgParserT__28)|(1<<OgParserT__29))) != 0 {
		p.SetState(436)
		_la = p.GetTokenStream().LA(1)

		if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__15)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__22)|(1<<OgParserT__23)|(1<<OgParserT__24)|(1<<OgParserT__25)|(1<<OgParserT__26)|(1<<OgParserT__27)|(1<<OgParserT__28)|(1<<OgParserT__29))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}

	}
	{
		p.SetState(439)
		p.Match(OgParserT__10)
	}

	return localctx
}

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

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

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

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

func NewEmptyShortVarDeclContext() *ShortVarDeclContext {
	var p = new(ShortVarDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_shortVarDecl
	return p
}

func (*ShortVarDeclContext) IsShortVarDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_shortVarDecl

	return p
}

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

func (s *ShortVarDeclContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *ShortVarDeclContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *ShortVarDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterShortVarDecl(s)
	}
}

func (s *ShortVarDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitShortVarDecl(s)
	}
}

func (s *ShortVarDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ShortVarDeclVisitor:
		return t.VisitShortVarDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ShortVarDecl() (localctx IShortVarDeclContext) {
	localctx = NewShortVarDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, OgParserRULE_shortVarDecl)

	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(441)
		p.IdentifierList()
	}
	{
		p.SetState(442)
		p.Match(OgParserT__30)
	}
	{
		p.SetState(443)
		p.ExpressionList()
	}

	return localctx
}

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

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

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

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

func NewEmptyEmptyStmtContext() *EmptyStmtContext {
	var p = new(EmptyStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_emptyStmt
	return p
}

func (*EmptyStmtContext) IsEmptyStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_emptyStmt

	return p
}

func (s *EmptyStmtContext) GetParser() antlr.Parser { return s.parser }
func (s *EmptyStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *EmptyStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterEmptyStmt(s)
	}
}

func (s *EmptyStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitEmptyStmt(s)
	}
}

func (s *EmptyStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case EmptyStmtVisitor:
		return t.VisitEmptyStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) EmptyStmt() (localctx IEmptyStmtContext) {
	localctx = NewEmptyStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, OgParserRULE_emptyStmt)

	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(445)
		p.Match(OgParserT__31)
	}

	return localctx
}

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

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

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

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

func NewEmptyLabeledStmtContext() *LabeledStmtContext {
	var p = new(LabeledStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_labeledStmt
	return p
}

func (*LabeledStmtContext) IsLabeledStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_labeledStmt

	return p
}

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

func (s *LabeledStmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *LabeledStmtContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *LabeledStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterLabeledStmt(s)
	}
}

func (s *LabeledStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitLabeledStmt(s)
	}
}

func (s *LabeledStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case LabeledStmtVisitor:
		return t.VisitLabeledStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) LabeledStmt() (localctx ILabeledStmtContext) {
	localctx = NewLabeledStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, OgParserRULE_labeledStmt)

	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(447)
		p.Match(OgParserT__32)
	}
	{
		p.SetState(448)
		p.Match(OgParserIDENTIFIER)
	}
	{
		p.SetState(449)
		p.Match(OgParserT__7)
	}
	{
		p.SetState(450)
		p.Statement()
	}

	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 = OgParserRULE_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 = OgParserRULE_returnStmt

	return p
}

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

func (s *ReturnStmtContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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.(OgListener); ok {
		listenerT.EnterReturnStmt(s)
	}
}

func (s *ReturnStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitReturnStmt(s)
	}
}

func (s *ReturnStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ReturnStmtVisitor:
		return t.VisitReturnStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ReturnStmt() (localctx IReturnStmtContext) {
	localctx = NewReturnStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, OgParserRULE_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(452)
		p.Match(OgParserT__33)
	}
	p.SetState(454)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(453)
			p.ExpressionList()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyBreakStmtContext() *BreakStmtContext {
	var p = new(BreakStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_breakStmt
	return p
}

func (*BreakStmtContext) IsBreakStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_breakStmt

	return p
}

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

func (s *BreakStmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *BreakStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterBreakStmt(s)
	}
}

func (s *BreakStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitBreakStmt(s)
	}
}

func (s *BreakStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case BreakStmtVisitor:
		return t.VisitBreakStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) BreakStmt() (localctx IBreakStmtContext) {
	localctx = NewBreakStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, OgParserRULE_breakStmt)

	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(456)
		p.Match(OgParserT__34)
	}
	p.SetState(458)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(457)
			p.Match(OgParserIDENTIFIER)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyContinueStmtContext() *ContinueStmtContext {
	var p = new(ContinueStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_continueStmt
	return p
}

func (*ContinueStmtContext) IsContinueStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_continueStmt

	return p
}

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

func (s *ContinueStmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *ContinueStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterContinueStmt(s)
	}
}

func (s *ContinueStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitContinueStmt(s)
	}
}

func (s *ContinueStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ContinueStmtVisitor:
		return t.VisitContinueStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ContinueStmt() (localctx IContinueStmtContext) {
	localctx = NewContinueStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, OgParserRULE_continueStmt)

	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(460)
		p.Match(OgParserT__35)
	}
	p.SetState(462)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(461)
			p.Match(OgParserIDENTIFIER)
		}

	}

	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 = OgParserRULE_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 = OgParserRULE_gotoStmt

	return p
}

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

func (s *GotoStmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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.(OgListener); ok {
		listenerT.EnterGotoStmt(s)
	}
}

func (s *GotoStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitGotoStmt(s)
	}
}

func (s *GotoStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case GotoStmtVisitor:
		return t.VisitGotoStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) GotoStmt() (localctx IGotoStmtContext) {
	localctx = NewGotoStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, OgParserRULE_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(464)
		p.Match(OgParserT__36)
	}
	{
		p.SetState(465)
		p.Match(OgParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyFallthroughStmtContext() *FallthroughStmtContext {
	var p = new(FallthroughStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_fallthroughStmt
	return p
}

func (*FallthroughStmtContext) IsFallthroughStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_fallthroughStmt

	return p
}

func (s *FallthroughStmtContext) GetParser() antlr.Parser { return s.parser }
func (s *FallthroughStmtContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *FallthroughStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFallthroughStmt(s)
	}
}

func (s *FallthroughStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFallthroughStmt(s)
	}
}

func (s *FallthroughStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FallthroughStmtVisitor:
		return t.VisitFallthroughStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) FallthroughStmt() (localctx IFallthroughStmtContext) {
	localctx = NewFallthroughStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, OgParserRULE_fallthroughStmt)

	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(467)
		p.Match(OgParserT__37)
	}

	return localctx
}

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

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

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

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

func NewEmptyDeferStmtContext() *DeferStmtContext {
	var p = new(DeferStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_deferStmt
	return p
}

func (*DeferStmtContext) IsDeferStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_deferStmt

	return p
}

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

func (s *DeferStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *DeferStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterDeferStmt(s)
	}
}

func (s *DeferStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitDeferStmt(s)
	}
}

func (s *DeferStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case DeferStmtVisitor:
		return t.VisitDeferStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) DeferStmt() (localctx IDeferStmtContext) {
	localctx = NewDeferStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, OgParserRULE_deferStmt)

	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(469)
		p.Match(OgParserT__38)
	}
	{
		p.SetState(470)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyIfStmtContext() *IfStmtContext {
	var p = new(IfStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_ifStmt
	return p
}

func (*IfStmtContext) IsIfStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_ifStmt

	return p
}

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

func (s *IfStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IfStmtContext) 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 *IfStmtContext) Block(i int) IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *IfStmtContext) SimpleStmt() ISimpleStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleStmtContext)
}

func (s *IfStmtContext) AllStatement() []IStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementContext)(nil)).Elem())
	var tst = make([]IStatementContext, len(ts))

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

	return tst
}

func (s *IfStmtContext) Statement(i int) IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *IfStmtContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *IfStmtContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *IfStmtContext) IfStmt() IIfStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfStmtContext)
}

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

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

func (s *IfStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterIfStmt(s)
	}
}

func (s *IfStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitIfStmt(s)
	}
}

func (s *IfStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case IfStmtVisitor:
		return t.VisitIfStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) IfStmt() (localctx IIfStmtContext) {
	localctx = NewIfStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, OgParserRULE_ifStmt)

	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(472)
		p.Match(OgParserT__39)
	}
	p.SetState(476)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 32, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(473)
			p.SimpleStmt()
		}
		{
			p.SetState(474)
			p.Match(OgParserT__31)
		}

	}
	{
		p.SetState(478)
		p.expression(0)
	}
	p.SetState(485)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__40:
		{
			p.SetState(479)
			p.Match(OgParserT__40)
		}
		{
			p.SetState(480)
			p.Statement()
		}
		{
			p.SetState(481)
			p.Eos()
		}

	case OgParserT__31:
		{
			p.SetState(483)
			p.Match(OgParserT__31)
		}
		{
			p.SetState(484)
			p.Block()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(498)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(487)
			p.Match(OgParserT__41)
		}
		p.SetState(496)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case OgParserT__39:
			{
				p.SetState(488)
				p.IfStmt()
			}

		case OgParserT__5, OgParserT__40:
			p.SetState(494)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case OgParserT__40:
				{
					p.SetState(489)
					p.Match(OgParserT__40)
				}
				{
					p.SetState(490)
					p.Statement()
				}
				{
					p.SetState(491)
					p.Eos()
				}

			case OgParserT__5:
				{
					p.SetState(493)
					p.Block()
				}

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

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

	}

	return localctx
}

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

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

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

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

func NewEmptySwitchStmtContext() *SwitchStmtContext {
	var p = new(SwitchStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_switchStmt
	return p
}

func (*SwitchStmtContext) IsSwitchStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_switchStmt

	return p
}

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

func (s *SwitchStmtContext) ExprSwitchStmt() IExprSwitchStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprSwitchStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprSwitchStmtContext)
}

func (s *SwitchStmtContext) TypeSwitchStmt() ITypeSwitchStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSwitchStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSwitchStmtContext)
}

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

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

func (s *SwitchStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSwitchStmt(s)
	}
}

func (s *SwitchStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSwitchStmt(s)
	}
}

func (s *SwitchStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SwitchStmtVisitor:
		return t.VisitSwitchStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SwitchStmt() (localctx ISwitchStmtContext) {
	localctx = NewSwitchStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, OgParserRULE_switchStmt)

	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(502)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(500)
			p.ExprSwitchStmt()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(501)
			p.TypeSwitchStmt()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExprSwitchStmtContext() *ExprSwitchStmtContext {
	var p = new(ExprSwitchStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_exprSwitchStmt
	return p
}

func (*ExprSwitchStmtContext) IsExprSwitchStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_exprSwitchStmt

	return p
}

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

func (s *ExprSwitchStmtContext) SimpleStmt() ISimpleStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleStmtContext)
}

func (s *ExprSwitchStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExprSwitchStmtContext) AllExprCaseClause() []IExprCaseClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprCaseClauseContext)(nil)).Elem())
	var tst = make([]IExprCaseClauseContext, len(ts))

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

	return tst
}

func (s *ExprSwitchStmtContext) ExprCaseClause(i int) IExprCaseClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprCaseClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprCaseClauseContext)
}

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

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

func (s *ExprSwitchStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterExprSwitchStmt(s)
	}
}

func (s *ExprSwitchStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitExprSwitchStmt(s)
	}
}

func (s *ExprSwitchStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ExprSwitchStmtVisitor:
		return t.VisitExprSwitchStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ExprSwitchStmt() (localctx IExprSwitchStmtContext) {
	localctx = NewExprSwitchStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, OgParserRULE_exprSwitchStmt)
	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(504)
		p.Match(OgParserT__42)
	}
	p.SetState(508)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(505)
			p.SimpleStmt()
		}
		{
			p.SetState(506)
			p.Match(OgParserT__31)
		}

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

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		{
			p.SetState(510)
			p.expression(0)
		}

	}
	{
		p.SetState(513)
		p.Match(OgParserT__5)
	}
	p.SetState(517)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__11)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		{
			p.SetState(514)
			p.ExprCaseClause()
		}

		p.SetState(519)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(520)
		p.Match(OgParserT__6)
	}

	return localctx
}

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

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

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

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

func NewEmptyExprCaseClauseContext() *ExprCaseClauseContext {
	var p = new(ExprCaseClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_exprCaseClause
	return p
}

func (*ExprCaseClauseContext) IsExprCaseClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_exprCaseClause

	return p
}

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

func (s *ExprCaseClauseContext) ExprSwitchCase() IExprSwitchCaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprSwitchCaseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprSwitchCaseContext)
}

func (s *ExprCaseClauseContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

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

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

func (s *ExprCaseClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterExprCaseClause(s)
	}
}

func (s *ExprCaseClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitExprCaseClause(s)
	}
}

func (s *ExprCaseClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ExprCaseClauseVisitor:
		return t.VisitExprCaseClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ExprCaseClause() (localctx IExprCaseClauseContext) {
	localctx = NewExprCaseClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, OgParserRULE_exprCaseClause)

	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(522)
		p.ExprSwitchCase()
	}
	{
		p.SetState(523)
		p.Match(OgParserT__40)
	}
	{
		p.SetState(524)
		p.StatementList()
	}

	return localctx
}

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

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

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

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

func NewEmptyExprSwitchCaseContext() *ExprSwitchCaseContext {
	var p = new(ExprSwitchCaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_exprSwitchCase
	return p
}

func (*ExprSwitchCaseContext) IsExprSwitchCaseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_exprSwitchCase

	return p
}

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

func (s *ExprSwitchCaseContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *ExprSwitchCaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterExprSwitchCase(s)
	}
}

func (s *ExprSwitchCaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitExprSwitchCase(s)
	}
}

func (s *ExprSwitchCaseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ExprSwitchCaseVisitor:
		return t.VisitExprSwitchCase(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ExprSwitchCase() (localctx IExprSwitchCaseContext) {
	localctx = NewExprSwitchCaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, OgParserRULE_exprSwitchCase)

	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(528)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__1, OgParserT__3, OgParserT__15, OgParserT__17, OgParserT__20, OgParserT__21, OgParserT__23, OgParserT__28, OgParserT__47, OgParserT__49, OgParserT__50, OgParserT__51, OgParserT__52, OgParserT__56, OgParserT__57, OgParserT__58, OgParserT__59, OgParserT__60, OgParserT__61, OgParserIDENTIFIER, OgParserINT_LIT, OgParserFLOAT_LIT, OgParserIMAGINARY_LIT, OgParserRUNE_LIT, OgParserSTRING_LIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(526)
			p.ExpressionList()
		}

	case OgParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(527)
			p.Match(OgParserT__11)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeSwitchStmtContext() *TypeSwitchStmtContext {
	var p = new(TypeSwitchStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeSwitchStmt
	return p
}

func (*TypeSwitchStmtContext) IsTypeSwitchStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeSwitchStmt

	return p
}

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

func (s *TypeSwitchStmtContext) TypeSwitchGuard() ITypeSwitchGuardContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSwitchGuardContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSwitchGuardContext)
}

func (s *TypeSwitchStmtContext) SimpleStmt() ISimpleStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleStmtContext)
}

func (s *TypeSwitchStmtContext) AllTypeCaseClause() []ITypeCaseClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeCaseClauseContext)(nil)).Elem())
	var tst = make([]ITypeCaseClauseContext, len(ts))

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

	return tst
}

func (s *TypeSwitchStmtContext) TypeCaseClause(i int) ITypeCaseClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeCaseClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeCaseClauseContext)
}

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

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

func (s *TypeSwitchStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeSwitchStmt(s)
	}
}

func (s *TypeSwitchStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeSwitchStmt(s)
	}
}

func (s *TypeSwitchStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeSwitchStmtVisitor:
		return t.VisitTypeSwitchStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeSwitchStmt() (localctx ITypeSwitchStmtContext) {
	localctx = NewTypeSwitchStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, OgParserRULE_typeSwitchStmt)
	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(530)
		p.Match(OgParserT__42)
	}
	p.SetState(534)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(531)
			p.SimpleStmt()
		}
		{
			p.SetState(532)
			p.Match(OgParserT__31)
		}

	}
	{
		p.SetState(536)
		p.TypeSwitchGuard()
	}
	{
		p.SetState(537)
		p.Match(OgParserT__5)
	}
	p.SetState(541)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__3)|(1<<OgParserT__11)|(1<<OgParserT__15)|(1<<OgParserT__17))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48)))) != 0) {
		{
			p.SetState(538)
			p.TypeCaseClause()
		}

		p.SetState(543)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(544)
		p.Match(OgParserT__6)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeSwitchGuardContext() *TypeSwitchGuardContext {
	var p = new(TypeSwitchGuardContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeSwitchGuard
	return p
}

func (*TypeSwitchGuardContext) IsTypeSwitchGuardContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeSwitchGuard

	return p
}

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

func (s *TypeSwitchGuardContext) PrimaryExpr() IPrimaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryExprContext)
}

func (s *TypeSwitchGuardContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *TypeSwitchGuardContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeSwitchGuard(s)
	}
}

func (s *TypeSwitchGuardContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeSwitchGuard(s)
	}
}

func (s *TypeSwitchGuardContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeSwitchGuardVisitor:
		return t.VisitTypeSwitchGuard(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeSwitchGuard() (localctx ITypeSwitchGuardContext) {
	localctx = NewTypeSwitchGuardContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, OgParserRULE_typeSwitchGuard)

	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(548)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(546)
			p.Match(OgParserIDENTIFIER)
		}
		{
			p.SetState(547)
			p.Match(OgParserT__30)
		}

	}
	{
		p.SetState(550)
		p.primaryExpr(0)
	}
	{
		p.SetState(551)
		p.Match(OgParserT__8)
	}
	{
		p.SetState(552)
		p.Match(OgParserT__3)
	}
	{
		p.SetState(553)
		p.Match(OgParserT__13)
	}
	{
		p.SetState(554)
		p.Match(OgParserT__4)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeCaseClauseContext() *TypeCaseClauseContext {
	var p = new(TypeCaseClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeCaseClause
	return p
}

func (*TypeCaseClauseContext) IsTypeCaseClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeCaseClause

	return p
}

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

func (s *TypeCaseClauseContext) TypeSwitchCase() ITypeSwitchCaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSwitchCaseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSwitchCaseContext)
}

func (s *TypeCaseClauseContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

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

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

func (s *TypeCaseClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeCaseClause(s)
	}
}

func (s *TypeCaseClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeCaseClause(s)
	}
}

func (s *TypeCaseClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeCaseClauseVisitor:
		return t.VisitTypeCaseClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeCaseClause() (localctx ITypeCaseClauseContext) {
	localctx = NewTypeCaseClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, OgParserRULE_typeCaseClause)

	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(556)
		p.TypeSwitchCase()
	}
	{
		p.SetState(557)
		p.Match(OgParserT__40)
	}
	{
		p.SetState(558)
		p.StatementList()
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeSwitchCaseContext() *TypeSwitchCaseContext {
	var p = new(TypeSwitchCaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeSwitchCase
	return p
}

func (*TypeSwitchCaseContext) IsTypeSwitchCaseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeSwitchCase

	return p
}

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

func (s *TypeSwitchCaseContext) TypeList() ITypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

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

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

func (s *TypeSwitchCaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeSwitchCase(s)
	}
}

func (s *TypeSwitchCaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeSwitchCase(s)
	}
}

func (s *TypeSwitchCaseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeSwitchCaseVisitor:
		return t.VisitTypeSwitchCase(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeSwitchCase() (localctx ITypeSwitchCaseContext) {
	localctx = NewTypeSwitchCaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, OgParserRULE_typeSwitchCase)

	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(562)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__3, OgParserT__15, OgParserT__17, OgParserT__47, OgParserT__49, OgParserT__50, OgParserT__51, OgParserT__52, OgParserT__59, OgParserT__60, OgParserT__61, OgParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(560)
			p.TypeList()
		}

	case OgParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(561)
			p.Match(OgParserT__11)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeListContext() *TypeListContext {
	var p = new(TypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeList
	return p
}

func (*TypeListContext) IsTypeListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeList

	return p
}

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

func (s *TypeListContext) AllType_() []IType_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IType_Context)(nil)).Elem())
	var tst = make([]IType_Context, len(ts))

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

	return tst
}

func (s *TypeListContext) Type_(i int) IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *TypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeList(s)
	}
}

func (s *TypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeList(s)
	}
}

func (s *TypeListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeListVisitor:
		return t.VisitTypeList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeList() (localctx ITypeListContext) {
	localctx = NewTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, OgParserRULE_typeList)
	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(564)
		p.Type_()
	}
	p.SetState(569)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == OgParserT__12 {
		{
			p.SetState(565)
			p.Match(OgParserT__12)
		}
		{
			p.SetState(566)
			p.Type_()
		}

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

	return localctx
}

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

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

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

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

func NewEmptySelectStmtContext() *SelectStmtContext {
	var p = new(SelectStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_selectStmt
	return p
}

func (*SelectStmtContext) IsSelectStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_selectStmt

	return p
}

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

func (s *SelectStmtContext) AllCommClause() []ICommClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICommClauseContext)(nil)).Elem())
	var tst = make([]ICommClauseContext, len(ts))

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

	return tst
}

func (s *SelectStmtContext) CommClause(i int) ICommClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICommClauseContext)
}

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

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

func (s *SelectStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSelectStmt(s)
	}
}

func (s *SelectStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSelectStmt(s)
	}
}

func (s *SelectStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SelectStmtVisitor:
		return t.VisitSelectStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SelectStmt() (localctx ISelectStmtContext) {
	localctx = NewSelectStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, OgParserRULE_selectStmt)
	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(572)
		p.Match(OgParserT__43)
	}
	{
		p.SetState(573)
		p.Match(OgParserT__5)
	}
	p.SetState(577)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__11)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		{
			p.SetState(574)
			p.CommClause()
		}

		p.SetState(579)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(580)
		p.Match(OgParserT__6)
	}

	return localctx
}

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

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

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

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

func NewEmptyCommClauseContext() *CommClauseContext {
	var p = new(CommClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_commClause
	return p
}

func (*CommClauseContext) IsCommClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_commClause

	return p
}

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

func (s *CommClauseContext) CommCase() ICommCaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommCaseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommCaseContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *CommClauseContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *CommClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterCommClause(s)
	}
}

func (s *CommClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitCommClause(s)
	}
}

func (s *CommClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case CommClauseVisitor:
		return t.VisitCommClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) CommClause() (localctx ICommClauseContext) {
	localctx = NewCommClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, OgParserRULE_commClause)

	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(582)
		p.CommCase()
	}
	{
		p.SetState(583)
		p.Match(OgParserT__40)
	}
	p.SetState(586)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 48, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(584)
			p.Block()
		}

	case 2:
		{
			p.SetState(585)
			p.Statement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCommCaseContext() *CommCaseContext {
	var p = new(CommCaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_commCase
	return p
}

func (*CommCaseContext) IsCommCaseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_commCase

	return p
}

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

func (s *CommCaseContext) SendStmt() ISendStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISendStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISendStmtContext)
}

func (s *CommCaseContext) RecvStmt() IRecvStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecvStmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecvStmtContext)
}

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

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

func (s *CommCaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterCommCase(s)
	}
}

func (s *CommCaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitCommCase(s)
	}
}

func (s *CommCaseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case CommCaseVisitor:
		return t.VisitCommCase(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) CommCase() (localctx ICommCaseContext) {
	localctx = NewCommCaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, OgParserRULE_commCase)

	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(593)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(590)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(588)
				p.SendStmt()
			}

		case 2:
			{
				p.SetState(589)
				p.RecvStmt()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(592)
			p.Match(OgParserT__11)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRecvStmtContext() *RecvStmtContext {
	var p = new(RecvStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_recvStmt
	return p
}

func (*RecvStmtContext) IsRecvStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_recvStmt

	return p
}

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

func (s *RecvStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *RecvStmtContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *RecvStmtContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

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

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

func (s *RecvStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterRecvStmt(s)
	}
}

func (s *RecvStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitRecvStmt(s)
	}
}

func (s *RecvStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case RecvStmtVisitor:
		return t.VisitRecvStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) RecvStmt() (localctx IRecvStmtContext) {
	localctx = NewRecvStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, OgParserRULE_recvStmt)

	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(601)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(595)
			p.ExpressionList()
		}
		{
			p.SetState(596)
			p.Match(OgParserT__10)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(598)
			p.IdentifierList()
		}
		{
			p.SetState(599)
			p.Match(OgParserT__30)
		}

	}
	{
		p.SetState(603)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyForStmtContext() *ForStmtContext {
	var p = new(ForStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_forStmt
	return p
}

func (*ForStmtContext) IsForStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_forStmt

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ForStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ForStmtContext) RangeClause() IRangeClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRangeClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRangeClauseContext)
}

func (s *ForStmtContext) ForClause() IForClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForClauseContext)
}

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

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

func (s *ForStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterForStmt(s)
	}
}

func (s *ForStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitForStmt(s)
	}
}

func (s *ForStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ForStmtVisitor:
		return t.VisitForStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ForStmt() (localctx IForStmtContext) {
	localctx = NewForStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, OgParserRULE_forStmt)

	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(605)
		p.Match(OgParserT__44)
	}
	p.SetState(609)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(606)
			p.expression(0)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(607)
			p.RangeClause()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(608)
			p.ForClause()
		}

	}
	{
		p.SetState(611)
		p.Match(OgParserT__31)
	}
	{
		p.SetState(612)
		p.Block()
	}

	return localctx
}

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

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

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

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

func NewEmptyForClauseContext() *ForClauseContext {
	var p = new(ForClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_forClause
	return p
}

func (*ForClauseContext) IsForClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_forClause

	return p
}

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

func (s *ForClauseContext) AllSimpleStmt() []ISimpleStmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem())
	var tst = make([]ISimpleStmtContext, len(ts))

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

	return tst
}

func (s *ForClauseContext) SimpleStmt(i int) ISimpleStmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISimpleStmtContext)
}

func (s *ForClauseContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ForClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterForClause(s)
	}
}

func (s *ForClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitForClause(s)
	}
}

func (s *ForClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ForClauseVisitor:
		return t.VisitForClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ForClause() (localctx IForClauseContext) {
	localctx = NewForClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, OgParserRULE_forClause)
	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(615)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(614)
			p.SimpleStmt()
		}

	}
	{
		p.SetState(617)
		p.Match(OgParserT__31)
	}
	p.SetState(619)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		{
			p.SetState(618)
			p.expression(0)
		}

	}
	{
		p.SetState(621)
		p.Match(OgParserT__31)
	}
	p.SetState(623)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(622)
			p.SimpleStmt()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRangeClauseContext() *RangeClauseContext {
	var p = new(RangeClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_rangeClause
	return p
}

func (*RangeClauseContext) IsRangeClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_rangeClause

	return p
}

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

func (s *RangeClauseContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *RangeClauseContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *RangeClauseContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *RangeClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterRangeClause(s)
	}
}

func (s *RangeClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitRangeClause(s)
	}
}

func (s *RangeClauseContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case RangeClauseVisitor:
		return t.VisitRangeClause(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) RangeClause() (localctx IRangeClauseContext) {
	localctx = NewRangeClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, OgParserRULE_rangeClause)

	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(627)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(625)
			p.IdentifierList()
		}

	case 2:
		{
			p.SetState(626)
			p.ExpressionList()
		}

	}
	{
		p.SetState(629)
		p.Match(OgParserT__45)
	}
	{
		p.SetState(630)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyGoStmtContext() *GoStmtContext {
	var p = new(GoStmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_goStmt
	return p
}

func (*GoStmtContext) IsGoStmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_goStmt

	return p
}

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

func (s *GoStmtContext) Function() IFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionContext)
}

func (s *GoStmtContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *GoStmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterGoStmt(s)
	}
}

func (s *GoStmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitGoStmt(s)
	}
}

func (s *GoStmtContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case GoStmtVisitor:
		return t.VisitGoStmt(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) GoStmt() (localctx IGoStmtContext) {
	localctx = NewGoStmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, OgParserRULE_goStmt)

	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(632)
		p.Match(OgParserT__46)
	}
	p.SetState(635)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 57, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(633)
			p.Function()
		}

	case 2:
		{
			p.SetState(634)
			p.expression(0)
		}

	}

	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 = OgParserRULE_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 = OgParserRULE_type_

	return p
}

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

func (s *Type_Context) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *Type_Context) TypeLit() ITypeLitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeLitContext)
}

func (s *Type_Context) 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 *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.(OgListener); ok {
		listenerT.EnterType_(s)
	}
}

func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitType_(s)
	}
}

func (s *Type_Context) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case Type_Visitor:
		return t.VisitType_(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Type_() (localctx IType_Context) {
	localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, OgParserRULE_type_)

	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(643)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__59, OgParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(637)
			p.TypeName()
		}

	case OgParserT__15, OgParserT__17, OgParserT__47, OgParserT__49, OgParserT__50, OgParserT__51, OgParserT__52, OgParserT__60, OgParserT__61:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(638)
			p.TypeLit()
		}

	case OgParserT__3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(639)
			p.Match(OgParserT__3)
		}
		{
			p.SetState(640)
			p.Type_()
		}
		{
			p.SetState(641)
			p.Match(OgParserT__4)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeNameContext() *TypeNameContext {
	var p = new(TypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeName
	return p
}

func (*TypeNameContext) IsTypeNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeName

	return p
}

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

func (s *TypeNameContext) QualifiedIdent() IQualifiedIdentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedIdentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedIdentContext)
}

func (s *TypeNameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

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

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

func (s *TypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeName(s)
	}
}

func (s *TypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeName(s)
	}
}

func (s *TypeNameContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeNameVisitor:
		return t.VisitTypeName(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeName() (localctx ITypeNameContext) {
	localctx = NewTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, OgParserRULE_typeName)

	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(647)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(645)
			p.QualifiedIdent()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(646)
			p.Match(OgParserIDENTIFIER)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTypeLitContext() *TypeLitContext {
	var p = new(TypeLitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeLit
	return p
}

func (*TypeLitContext) IsTypeLitContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeLit

	return p
}

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

func (s *TypeLitContext) ArrayType() IArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayTypeContext)
}

func (s *TypeLitContext) StructType() IStructTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructTypeContext)
}

func (s *TypeLitContext) PointerType() IPointerTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPointerTypeContext)
}

func (s *TypeLitContext) FunctionType() IFunctionTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionTypeContext)
}

func (s *TypeLitContext) InterfaceType() IInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeContext)
}

func (s *TypeLitContext) SliceType() ISliceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISliceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISliceTypeContext)
}

func (s *TypeLitContext) MapType() IMapTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMapTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMapTypeContext)
}

func (s *TypeLitContext) ChannelType() IChannelTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IChannelTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IChannelTypeContext)
}

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

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

func (s *TypeLitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeLit(s)
	}
}

func (s *TypeLitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeLit(s)
	}
}

func (s *TypeLitContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeLitVisitor:
		return t.VisitTypeLit(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeLit() (localctx ITypeLitContext) {
	localctx = NewTypeLitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, OgParserRULE_typeLit)

	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(657)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 60, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(649)
			p.ArrayType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(650)
			p.StructType()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(651)
			p.PointerType()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(652)
			p.FunctionType()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(653)
			p.InterfaceType()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(654)
			p.SliceType()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(655)
			p.MapType()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(656)
			p.ChannelType()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyArrayTypeContext() *ArrayTypeContext {
	var p = new(ArrayTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_arrayType
	return p
}

func (*ArrayTypeContext) IsArrayTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_arrayType

	return p
}

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

func (s *ArrayTypeContext) ArrayLength() IArrayLengthContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLengthContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayLengthContext)
}

func (s *ArrayTypeContext) ElementType() IElementTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementTypeContext)
}

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

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

func (s *ArrayTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterArrayType(s)
	}
}

func (s *ArrayTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitArrayType(s)
	}
}

func (s *ArrayTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ArrayTypeVisitor:
		return t.VisitArrayType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ArrayType() (localctx IArrayTypeContext) {
	localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, OgParserRULE_arrayType)

	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(659)
		p.Match(OgParserT__47)
	}
	{
		p.SetState(660)
		p.ArrayLength()
	}
	{
		p.SetState(661)
		p.Match(OgParserT__48)
	}
	{
		p.SetState(662)
		p.ElementType()
	}

	return localctx
}

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

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

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

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

func NewEmptyArrayLengthContext() *ArrayLengthContext {
	var p = new(ArrayLengthContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_arrayLength
	return p
}

func (*ArrayLengthContext) IsArrayLengthContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_arrayLength

	return p
}

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

func (s *ArrayLengthContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ArrayLengthContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterArrayLength(s)
	}
}

func (s *ArrayLengthContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitArrayLength(s)
	}
}

func (s *ArrayLengthContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ArrayLengthVisitor:
		return t.VisitArrayLength(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ArrayLength() (localctx IArrayLengthContext) {
	localctx = NewArrayLengthContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, OgParserRULE_arrayLength)

	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(664)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyElementTypeContext() *ElementTypeContext {
	var p = new(ElementTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_elementType
	return p
}

func (*ElementTypeContext) IsElementTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_elementType

	return p
}

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

func (s *ElementTypeContext) 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 *ElementTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *ElementTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterElementType(s)
	}
}

func (s *ElementTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitElementType(s)
	}
}

func (s *ElementTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ElementTypeVisitor:
		return t.VisitElementType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ElementType() (localctx IElementTypeContext) {
	localctx = NewElementTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, OgParserRULE_elementType)

	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(666)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyPointerTypeContext() *PointerTypeContext {
	var p = new(PointerTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_pointerType
	return p
}

func (*PointerTypeContext) IsPointerTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_pointerType

	return p
}

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

func (s *PointerTypeContext) 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 *PointerTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *PointerTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterPointerType(s)
	}
}

func (s *PointerTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitPointerType(s)
	}
}

func (s *PointerTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case PointerTypeVisitor:
		return t.VisitPointerType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) PointerType() (localctx IPointerTypeContext) {
	localctx = NewPointerTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, OgParserRULE_pointerType)

	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(668)
		p.Match(OgParserT__15)
	}
	{
		p.SetState(669)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyInterfaceTypeContext() *InterfaceTypeContext {
	var p = new(InterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_interfaceType
	return p
}

func (*InterfaceTypeContext) IsInterfaceTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_interfaceType

	return p
}

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

func (s *InterfaceTypeContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *InterfaceTypeContext) AllMethodSpec() []IMethodSpecContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMethodSpecContext)(nil)).Elem())
	var tst = make([]IMethodSpecContext, len(ts))

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

	return tst
}

func (s *InterfaceTypeContext) MethodSpec(i int) IMethodSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodSpecContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IMethodSpecContext)
}

func (s *InterfaceTypeContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

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

	return tst
}

func (s *InterfaceTypeContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

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

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

func (s *InterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterInterfaceType(s)
	}
}

func (s *InterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitInterfaceType(s)
	}
}

func (s *InterfaceTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case InterfaceTypeVisitor:
		return t.VisitInterfaceType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) InterfaceType() (localctx IInterfaceTypeContext) {
	localctx = NewInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, OgParserRULE_interfaceType)

	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(671)
		p.Match(OgParserT__49)
	}
	p.SetState(673)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 61, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(672)
			p.Match(OgParserIDENTIFIER)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(675)
			p.Match(OgParserT__5)
		}
		p.SetState(681)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 62, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(676)
					p.MethodSpec()
				}
				{
					p.SetState(677)
					p.Eos()
				}

			}
			p.SetState(683)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 62, p.GetParserRuleContext())
		}
		{
			p.SetState(684)
			p.Match(OgParserT__6)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySliceTypeContext() *SliceTypeContext {
	var p = new(SliceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_sliceType
	return p
}

func (*SliceTypeContext) IsSliceTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_sliceType

	return p
}

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

func (s *SliceTypeContext) ElementType() IElementTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementTypeContext)
}

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

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

func (s *SliceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSliceType(s)
	}
}

func (s *SliceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSliceType(s)
	}
}

func (s *SliceTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SliceTypeVisitor:
		return t.VisitSliceType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SliceType() (localctx ISliceTypeContext) {
	localctx = NewSliceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, OgParserRULE_sliceType)

	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(687)
		p.Match(OgParserT__47)
	}
	{
		p.SetState(688)
		p.Match(OgParserT__48)
	}
	{
		p.SetState(689)
		p.ElementType()
	}

	return localctx
}

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

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

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

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

func NewEmptyMapTypeContext() *MapTypeContext {
	var p = new(MapTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_mapType
	return p
}

func (*MapTypeContext) IsMapTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_mapType

	return p
}

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

func (s *MapTypeContext) 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 *MapTypeContext) ElementType() IElementTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementTypeContext)
}

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

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

func (s *MapTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterMapType(s)
	}
}

func (s *MapTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitMapType(s)
	}
}

func (s *MapTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case MapTypeVisitor:
		return t.VisitMapType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) MapType() (localctx IMapTypeContext) {
	localctx = NewMapTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, OgParserRULE_mapType)

	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(691)
		p.Match(OgParserT__50)
	}
	{
		p.SetState(692)
		p.Match(OgParserT__47)
	}
	{
		p.SetState(693)
		p.Type_()
	}
	{
		p.SetState(694)
		p.Match(OgParserT__48)
	}
	{
		p.SetState(695)
		p.ElementType()
	}

	return localctx
}

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

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

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

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

func NewEmptyChannelTypeContext() *ChannelTypeContext {
	var p = new(ChannelTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_channelType
	return p
}

func (*ChannelTypeContext) IsChannelTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_channelType

	return p
}

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

func (s *ChannelTypeContext) ChannelDecl() IChannelDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IChannelDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IChannelDeclContext)
}

func (s *ChannelTypeContext) ElementType() IElementTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementTypeContext)
}

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

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

func (s *ChannelTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterChannelType(s)
	}
}

func (s *ChannelTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitChannelType(s)
	}
}

func (s *ChannelTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ChannelTypeVisitor:
		return t.VisitChannelType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ChannelType() (localctx IChannelTypeContext) {
	localctx = NewChannelTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, OgParserRULE_channelType)

	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(697)
		p.ChannelDecl()
	}
	{
		p.SetState(698)
		p.ElementType()
	}

	return localctx
}

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

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

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

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

func NewEmptyChannelDeclContext() *ChannelDeclContext {
	var p = new(ChannelDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_channelDecl
	return p
}

func (*ChannelDeclContext) IsChannelDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_channelDecl

	return p
}

func (s *ChannelDeclContext) GetParser() antlr.Parser { return s.parser }
func (s *ChannelDeclContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *ChannelDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterChannelDecl(s)
	}
}

func (s *ChannelDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitChannelDecl(s)
	}
}

func (s *ChannelDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ChannelDeclVisitor:
		return t.VisitChannelDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ChannelDecl() (localctx IChannelDeclContext) {
	localctx = NewChannelDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, OgParserRULE_channelDecl)

	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(705)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(700)
			p.Match(OgParserT__51)
		}

	case 2:
		{
			p.SetState(701)
			p.Match(OgParserT__51)
		}
		{
			p.SetState(702)
			p.Match(OgParserT__17)
		}

	case 3:
		{
			p.SetState(703)
			p.Match(OgParserT__17)
		}
		{
			p.SetState(704)
			p.Match(OgParserT__51)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMethodSpecContext() *MethodSpecContext {
	var p = new(MethodSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_methodSpec
	return p
}

func (*MethodSpecContext) IsMethodSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_methodSpec

	return p
}

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

func (s *MethodSpecContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *MethodSpecContext) Parameters() IParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParametersContext)
}

func (s *MethodSpecContext) Result() IResultContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResultContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResultContext)
}

func (s *MethodSpecContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

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

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

func (s *MethodSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterMethodSpec(s)
	}
}

func (s *MethodSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitMethodSpec(s)
	}
}

func (s *MethodSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case MethodSpecVisitor:
		return t.VisitMethodSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) MethodSpec() (localctx IMethodSpecContext) {
	localctx = NewMethodSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, OgParserRULE_methodSpec)

	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(716)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 65, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(707)

		if !(p.noTerminatorAfterParams(2)) {
			panic(antlr.NewFailedPredicateException(p, "p.noTerminatorAfterParams(2)", ""))
		}
		{
			p.SetState(708)
			p.Match(OgParserIDENTIFIER)
		}
		{
			p.SetState(709)
			p.Parameters()
		}
		{
			p.SetState(710)
			p.Match(OgParserT__7)
		}
		{
			p.SetState(711)
			p.Result()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(713)
			p.TypeName()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(714)
			p.Match(OgParserIDENTIFIER)
		}
		{
			p.SetState(715)
			p.Parameters()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionTypeContext() *FunctionTypeContext {
	var p = new(FunctionTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_functionType
	return p
}

func (*FunctionTypeContext) IsFunctionTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_functionType

	return p
}

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

func (s *FunctionTypeContext) Signature() ISignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISignatureContext)
}

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

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

func (s *FunctionTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFunctionType(s)
	}
}

func (s *FunctionTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFunctionType(s)
	}
}

func (s *FunctionTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FunctionTypeVisitor:
		return t.VisitFunctionType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) FunctionType() (localctx IFunctionTypeContext) {
	localctx = NewFunctionTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, OgParserRULE_functionType)

	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(718)
		p.Match(OgParserT__52)
	}
	{
		p.SetState(719)
		p.Signature()
	}

	return localctx
}

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

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

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

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

func NewEmptySignatureContext() *SignatureContext {
	var p = new(SignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_signature
	return p
}

func (*SignatureContext) IsSignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_signature

	return p
}

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

func (s *SignatureContext) Parameters() IParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParametersContext)
}

func (s *SignatureContext) Result() IResultContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResultContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResultContext)
}

func (s *SignatureContext) TemplateSpec() ITemplateSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITemplateSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITemplateSpecContext)
}

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

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

func (s *SignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSignature(s)
	}
}

func (s *SignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSignature(s)
	}
}

func (s *SignatureContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SignatureVisitor:
		return t.VisitSignature(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Signature() (localctx ISignatureContext) {
	localctx = NewSignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, OgParserRULE_signature)
	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(733)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(721)

		if !(p.noTerminatorAfterParams(1)) {
			panic(antlr.NewFailedPredicateException(p, "p.noTerminatorAfterParams(1)", ""))
		}
		p.SetState(723)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == OgParserT__53 {
			{
				p.SetState(722)
				p.TemplateSpec()
			}

		}
		{
			p.SetState(725)
			p.Parameters()
		}
		{
			p.SetState(726)
			p.Match(OgParserT__7)
		}
		{
			p.SetState(727)
			p.Result()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(730)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 67, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(729)
				p.TemplateSpec()
			}

		}
		{
			p.SetState(732)
			p.Parameters()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTemplateSpecContext() *TemplateSpecContext {
	var p = new(TemplateSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_templateSpec
	return p
}

func (*TemplateSpecContext) IsTemplateSpecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_templateSpec

	return p
}

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

func (s *TemplateSpecContext) Result() IResultContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResultContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResultContext)
}

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

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

func (s *TemplateSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTemplateSpec(s)
	}
}

func (s *TemplateSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTemplateSpec(s)
	}
}

func (s *TemplateSpecContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TemplateSpecVisitor:
		return t.VisitTemplateSpec(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TemplateSpec() (localctx ITemplateSpecContext) {
	localctx = NewTemplateSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, OgParserRULE_templateSpec)

	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(735)
		p.Match(OgParserT__53)
	}
	{
		p.SetState(736)
		p.Result()
	}
	{
		p.SetState(737)
		p.Match(OgParserT__54)
	}

	return localctx
}

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

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

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

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

func NewEmptyResultContext() *ResultContext {
	var p = new(ResultContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_result
	return p
}

func (*ResultContext) IsResultContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_result

	return p
}

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

func (s *ResultContext) AllType_() []IType_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IType_Context)(nil)).Elem())
	var tst = make([]IType_Context, len(ts))

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

	return tst
}

func (s *ResultContext) Type_(i int) IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *ResultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterResult(s)
	}
}

func (s *ResultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitResult(s)
	}
}

func (s *ResultContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ResultVisitor:
		return t.VisitResult(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Result() (localctx IResultContext) {
	localctx = NewResultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, OgParserRULE_result)

	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(739)
		p.Type_()
	}
	p.SetState(744)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(740)
				p.Match(OgParserT__12)
			}
			{
				p.SetState(741)
				p.Type_()
			}

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

	return localctx
}

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

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

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

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

func NewEmptyParametersContext() *ParametersContext {
	var p = new(ParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_parameters
	return p
}

func (*ParametersContext) IsParametersContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_parameters

	return p
}

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

func (s *ParametersContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

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

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

func (s *ParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterParameters(s)
	}
}

func (s *ParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitParameters(s)
	}
}

func (s *ParametersContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ParametersVisitor:
		return t.VisitParameters(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Parameters() (localctx IParametersContext) {
	localctx = NewParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, OgParserRULE_parameters)
	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(755)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(747)
			p.Match(OgParserT__3)
		}
		p.SetState(752)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__3)|(1<<OgParserT__11)|(1<<OgParserT__15)|(1<<OgParserT__17))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__55-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48)))) != 0) {
			{
				p.SetState(748)
				p.ParameterList()
			}
			p.SetState(750)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == OgParserT__12 {
				{
					p.SetState(749)
					p.Match(OgParserT__12)
				}

			}

		}
		{
			p.SetState(754)
			p.Match(OgParserT__4)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyParameterListContext() *ParameterListContext {
	var p = new(ParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_parameterList
	return p
}

func (*ParameterListContext) IsParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_parameterList

	return p
}

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

func (s *ParameterListContext) AllParameterDecl() []IParameterDeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParameterDeclContext)(nil)).Elem())
	var tst = make([]IParameterDeclContext, len(ts))

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

	return tst
}

func (s *ParameterListContext) ParameterDecl(i int) IParameterDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterDeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IParameterDeclContext)
}

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

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

func (s *ParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterParameterList(s)
	}
}

func (s *ParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitParameterList(s)
	}
}

func (s *ParameterListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ParameterListVisitor:
		return t.VisitParameterList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ParameterList() (localctx IParameterListContext) {
	localctx = NewParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, OgParserRULE_parameterList)

	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(757)
		p.ParameterDecl()
	}
	p.SetState(762)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(758)
				p.Match(OgParserT__12)
			}
			{
				p.SetState(759)
				p.ParameterDecl()
			}

		}
		p.SetState(764)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyParameterDeclContext() *ParameterDeclContext {
	var p = new(ParameterDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_parameterDecl
	return p
}

func (*ParameterDeclContext) IsParameterDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_parameterDecl

	return p
}

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

func (s *ParameterDeclContext) 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 *ParameterDeclContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *ParameterDeclContext) RestOp() IRestOpContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRestOpContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRestOpContext)
}

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

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

func (s *ParameterDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterParameterDecl(s)
	}
}

func (s *ParameterDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitParameterDecl(s)
	}
}

func (s *ParameterDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ParameterDeclVisitor:
		return t.VisitParameterDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ParameterDecl() (localctx IParameterDeclContext) {
	localctx = NewParameterDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, OgParserRULE_parameterDecl)
	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(766)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(765)
			p.IdentifierList()
		}

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

	if _la == OgParserT__55 {
		{
			p.SetState(768)
			p.RestOp()
		}

	}
	{
		p.SetState(771)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyRestOpContext() *RestOpContext {
	var p = new(RestOpContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_restOp
	return p
}

func (*RestOpContext) IsRestOpContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_restOp

	return p
}

func (s *RestOpContext) GetParser() antlr.Parser { return s.parser }
func (s *RestOpContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *RestOpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterRestOp(s)
	}
}

func (s *RestOpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitRestOp(s)
	}
}

func (s *RestOpContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case RestOpVisitor:
		return t.VisitRestOp(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) RestOp() (localctx IRestOpContext) {
	localctx = NewRestOpContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, OgParserRULE_restOp)

	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(773)
		p.Match(OgParserT__55)
	}

	return localctx
}

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

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

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

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

func NewEmptyOperandContext() *OperandContext {
	var p = new(OperandContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_operand
	return p
}

func (*OperandContext) IsOperandContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_operand

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *OperandContext) OperandName() IOperandNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOperandNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOperandNameContext)
}

func (s *OperandContext) MethodExpr() IMethodExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodExprContext)
}

func (s *OperandContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *OperandContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterOperand(s)
	}
}

func (s *OperandContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitOperand(s)
	}
}

func (s *OperandContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case OperandVisitor:
		return t.VisitOperand(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Operand() (localctx IOperandContext) {
	localctx = NewOperandContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, OgParserRULE_operand)

	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(782)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(775)
			p.Literal()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(776)
			p.OperandName()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(777)
			p.MethodExpr()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(778)
			p.Match(OgParserT__3)
		}
		{
			p.SetState(779)
			p.expression(0)
		}
		{
			p.SetState(780)
			p.Match(OgParserT__4)
		}

	}

	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 = OgParserRULE_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 = OgParserRULE_literal

	return p
}

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

func (s *LiteralContext) BasicLit() IBasicLitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBasicLitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBasicLitContext)
}

func (s *LiteralContext) CompositeLit() ICompositeLitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompositeLitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompositeLitContext)
}

func (s *LiteralContext) FunctionLit() IFunctionLitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionLitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionLitContext)
}

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.(OgListener); ok {
		listenerT.EnterLiteral(s)
	}
}

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitLiteral(s)
	}
}

func (s *LiteralContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case LiteralVisitor:
		return t.VisitLiteral(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Literal() (localctx ILiteralContext) {
	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, OgParserRULE_literal)

	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(787)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__56, OgParserT__57, OgParserT__58, OgParserINT_LIT, OgParserFLOAT_LIT, OgParserIMAGINARY_LIT, OgParserRUNE_LIT, OgParserSTRING_LIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(784)
			p.BasicLit()
		}

	case OgParserT__47, OgParserT__50, OgParserT__59, OgParserT__60, OgParserT__61, OgParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(785)
			p.CompositeLit()
		}

	case OgParserT__52:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(786)
			p.FunctionLit()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyBasicLitContext() *BasicLitContext {
	var p = new(BasicLitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_basicLit
	return p
}

func (*BasicLitContext) IsBasicLitContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_basicLit

	return p
}

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

func (s *BasicLitContext) INT_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserINT_LIT, 0)
}

func (s *BasicLitContext) FLOAT_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserFLOAT_LIT, 0)
}

func (s *BasicLitContext) IMAGINARY_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserIMAGINARY_LIT, 0)
}

func (s *BasicLitContext) RUNE_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserRUNE_LIT, 0)
}

func (s *BasicLitContext) STRING_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserSTRING_LIT, 0)
}

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

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

func (s *BasicLitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterBasicLit(s)
	}
}

func (s *BasicLitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitBasicLit(s)
	}
}

func (s *BasicLitContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case BasicLitVisitor:
		return t.VisitBasicLit(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) BasicLit() (localctx IBasicLitContext) {
	localctx = NewBasicLitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, OgParserRULE_basicLit)
	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(796)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserINT_LIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(789)
			p.Match(OgParserINT_LIT)
		}

	case OgParserFLOAT_LIT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(790)
			p.Match(OgParserFLOAT_LIT)
		}

	case OgParserIMAGINARY_LIT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(791)
			p.Match(OgParserIMAGINARY_LIT)
		}

	case OgParserRUNE_LIT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(792)
			p.Match(OgParserRUNE_LIT)
		}

	case OgParserSTRING_LIT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(793)
			p.Match(OgParserSTRING_LIT)
		}

	case OgParserT__56, OgParserT__57:
		p.EnterOuterAlt(localctx, 6)
		p.SetState(794)
		_la = p.GetTokenStream().LA(1)

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

	case OgParserT__58:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(795)
			p.Match(OgParserT__58)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOperandNameContext() *OperandNameContext {
	var p = new(OperandNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_operandName
	return p
}

func (*OperandNameContext) IsOperandNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_operandName

	return p
}

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

func (s *OperandNameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *OperandNameContext) QualifiedIdent() IQualifiedIdentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedIdentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedIdentContext)
}

func (s *OperandNameContext) This_() IThis_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IThis_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IThis_Context)
}

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

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

func (s *OperandNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterOperandName(s)
	}
}

func (s *OperandNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitOperandName(s)
	}
}

func (s *OperandNameContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case OperandNameVisitor:
		return t.VisitOperandName(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) OperandName() (localctx IOperandNameContext) {
	localctx = NewOperandNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, OgParserRULE_operandName)

	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(801)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(798)
			p.Match(OgParserIDENTIFIER)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(799)
			p.QualifiedIdent()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(800)
			p.This_()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyThis_Context() *This_Context {
	var p = new(This_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_this_
	return p
}

func (*This_Context) IsThis_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_this_

	return p
}

func (s *This_Context) GetParser() antlr.Parser { return s.parser }
func (s *This_Context) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *This_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterThis_(s)
	}
}

func (s *This_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitThis_(s)
	}
}

func (s *This_Context) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case This_Visitor:
		return t.VisitThis_(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) This_() (localctx IThis_Context) {
	localctx = NewThis_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, OgParserRULE_this_)

	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(803)
		p.Match(OgParserT__59)
	}

	return localctx
}

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

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

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

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

func NewEmptyQualifiedIdentContext() *QualifiedIdentContext {
	var p = new(QualifiedIdentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_qualifiedIdent
	return p
}

func (*QualifiedIdentContext) IsQualifiedIdentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_qualifiedIdent

	return p
}

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

func (s *QualifiedIdentContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(OgParserIDENTIFIER)
}

func (s *QualifiedIdentContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, i)
}

func (s *QualifiedIdentContext) This_() IThis_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IThis_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IThis_Context)
}

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

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

func (s *QualifiedIdentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterQualifiedIdent(s)
	}
}

func (s *QualifiedIdentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitQualifiedIdent(s)
	}
}

func (s *QualifiedIdentContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case QualifiedIdentVisitor:
		return t.VisitQualifiedIdent(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) QualifiedIdent() (localctx IQualifiedIdentContext) {
	localctx = NewQualifiedIdentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, OgParserRULE_qualifiedIdent)

	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(811)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(805)
			p.Match(OgParserIDENTIFIER)
		}
		{
			p.SetState(806)
			p.Match(OgParserT__8)
		}
		{
			p.SetState(807)
			p.Match(OgParserIDENTIFIER)
		}

	case OgParserT__59:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(808)
			p.This_()
		}
		{
			p.SetState(809)
			p.Match(OgParserIDENTIFIER)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCompositeLitContext() *CompositeLitContext {
	var p = new(CompositeLitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_compositeLit
	return p
}

func (*CompositeLitContext) IsCompositeLitContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_compositeLit

	return p
}

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

func (s *CompositeLitContext) LiteralType() ILiteralTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralTypeContext)
}

func (s *CompositeLitContext) LiteralValue() ILiteralValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralValueContext)
}

func (s *CompositeLitContext) TemplateSpec() ITemplateSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITemplateSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITemplateSpecContext)
}

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

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

func (s *CompositeLitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterCompositeLit(s)
	}
}

func (s *CompositeLitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitCompositeLit(s)
	}
}

func (s *CompositeLitContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case CompositeLitVisitor:
		return t.VisitCompositeLit(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) CompositeLit() (localctx ICompositeLitContext) {
	localctx = NewCompositeLitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, OgParserRULE_compositeLit)
	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(813)
		p.LiteralType()
	}
	p.SetState(815)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__53 {
		{
			p.SetState(814)
			p.TemplateSpec()
		}

	}
	{
		p.SetState(817)
		p.LiteralValue()
	}

	return localctx
}

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

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

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

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

func NewEmptyLiteralTypeContext() *LiteralTypeContext {
	var p = new(LiteralTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_literalType
	return p
}

func (*LiteralTypeContext) IsLiteralTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_literalType

	return p
}

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

func (s *LiteralTypeContext) StructType() IStructTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructTypeContext)
}

func (s *LiteralTypeContext) ArrayType() IArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayTypeContext)
}

func (s *LiteralTypeContext) ElementType() IElementTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementTypeContext)
}

func (s *LiteralTypeContext) SliceType() ISliceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISliceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISliceTypeContext)
}

func (s *LiteralTypeContext) MapType() IMapTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMapTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMapTypeContext)
}

func (s *LiteralTypeContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

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

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

func (s *LiteralTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterLiteralType(s)
	}
}

func (s *LiteralTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitLiteralType(s)
	}
}

func (s *LiteralTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case LiteralTypeVisitor:
		return t.VisitLiteralType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) LiteralType() (localctx ILiteralTypeContext) {
	localctx = NewLiteralTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, OgParserRULE_literalType)

	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(828)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(819)
			p.StructType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(820)
			p.ArrayType()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(821)
			p.Match(OgParserT__47)
		}
		{
			p.SetState(822)
			p.Match(OgParserT__55)
		}
		{
			p.SetState(823)
			p.Match(OgParserT__48)
		}
		{
			p.SetState(824)
			p.ElementType()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(825)
			p.SliceType()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(826)
			p.MapType()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(827)
			p.TypeName()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyLiteralValueContext() *LiteralValueContext {
	var p = new(LiteralValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_literalValue
	return p
}

func (*LiteralValueContext) IsLiteralValueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_literalValue

	return p
}

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

func (s *LiteralValueContext) ElementList() IElementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementListContext)
}

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

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

func (s *LiteralValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterLiteralValue(s)
	}
}

func (s *LiteralValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitLiteralValue(s)
	}
}

func (s *LiteralValueContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case LiteralValueVisitor:
		return t.VisitLiteralValue(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) LiteralValue() (localctx ILiteralValueContext) {
	localctx = NewLiteralValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, OgParserRULE_literalValue)
	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(830)
		p.Match(OgParserT__5)
	}
	p.SetState(835)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__5)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		{
			p.SetState(831)
			p.ElementList()
		}
		p.SetState(833)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == OgParserT__12 {
			{
				p.SetState(832)
				p.Match(OgParserT__12)
			}

		}

	}
	{
		p.SetState(837)
		p.Match(OgParserT__6)
	}

	return localctx
}

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

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

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

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

func NewEmptyElementListContext() *ElementListContext {
	var p = new(ElementListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_elementList
	return p
}

func (*ElementListContext) IsElementListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_elementList

	return p
}

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

func (s *ElementListContext) AllKeyedElement() []IKeyedElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKeyedElementContext)(nil)).Elem())
	var tst = make([]IKeyedElementContext, len(ts))

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

	return tst
}

func (s *ElementListContext) KeyedElement(i int) IKeyedElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyedElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKeyedElementContext)
}

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

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

func (s *ElementListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterElementList(s)
	}
}

func (s *ElementListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitElementList(s)
	}
}

func (s *ElementListContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ElementListVisitor:
		return t.VisitElementList(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ElementList() (localctx IElementListContext) {
	localctx = NewElementListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, OgParserRULE_elementList)
	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(839)
		p.KeyedElement()
	}
	p.SetState(846)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext())

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

			if _la == OgParserT__12 {
				{
					p.SetState(840)
					p.Match(OgParserT__12)
				}

			}
			{
				p.SetState(843)
				p.KeyedElement()
			}

		}
		p.SetState(848)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyKeyedElementContext() *KeyedElementContext {
	var p = new(KeyedElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_keyedElement
	return p
}

func (*KeyedElementContext) IsKeyedElementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = OgParserRULE_keyedElement

	return p
}

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

func (s *KeyedElementContext) Element() IElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementContext)
}

func (s *KeyedElementContext) Key() IKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyContext)
}

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

func (s *KeyedElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KeyedElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterKeyedElement(s)
	}
}

func (s *KeyedElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitKeyedElement(s)
	}
}

func (s *KeyedElementContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case KeyedElementVisitor:
		return t.VisitKeyedElement(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) KeyedElement() (localctx IKeyedElementContext) {
	localctx = NewKeyedElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, OgParserRULE_keyedElement)

	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(852)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(849)
			p.Key()
		}
		{
			p.SetState(850)
			p.Match(OgParserT__7)
		}

	}
	{
		p.SetState(854)
		p.Element()
	}

	return localctx
}

// IKeyContext is an interface to support dynamic dispatch.
type IKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKeyContext differentiates from other interfaces.
	IsKeyContext()
}

type KeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKeyContext() *KeyContext {
	var p = new(KeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_key
	return p
}

func (*KeyContext) IsKeyContext() {}

func NewKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyContext {
	var p = new(KeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_key

	return p
}

func (s *KeyContext) GetParser() antlr.Parser { return s.parser }

func (s *KeyContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *KeyContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *KeyContext) LiteralValue() ILiteralValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralValueContext)
}

func (s *KeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterKey(s)
	}
}

func (s *KeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitKey(s)
	}
}

func (s *KeyContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case KeyVisitor:
		return t.VisitKey(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Key() (localctx IKeyContext) {
	localctx = NewKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, OgParserRULE_key)

	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(859)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 88, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(856)
			p.Match(OgParserIDENTIFIER)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(857)
			p.expression(0)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(858)
			p.LiteralValue()
		}

	}

	return localctx
}

// IElementContext is an interface to support dynamic dispatch.
type IElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementContext differentiates from other interfaces.
	IsElementContext()
}

type ElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementContext() *ElementContext {
	var p = new(ElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_element
	return p
}

func (*ElementContext) IsElementContext() {}

func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext {
	var p = new(ElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_element

	return p
}

func (s *ElementContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ElementContext) LiteralValue() ILiteralValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralValueContext)
}

func (s *ElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterElement(s)
	}
}

func (s *ElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitElement(s)
	}
}

func (s *ElementContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ElementVisitor:
		return t.VisitElement(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Element() (localctx IElementContext) {
	localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, OgParserRULE_element)

	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(863)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case OgParserT__1, OgParserT__3, OgParserT__15, OgParserT__17, OgParserT__20, OgParserT__21, OgParserT__23, OgParserT__28, OgParserT__47, OgParserT__49, OgParserT__50, OgParserT__51, OgParserT__52, OgParserT__56, OgParserT__57, OgParserT__58, OgParserT__59, OgParserT__60, OgParserT__61, OgParserIDENTIFIER, OgParserINT_LIT, OgParserFLOAT_LIT, OgParserIMAGINARY_LIT, OgParserRUNE_LIT, OgParserSTRING_LIT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(861)
			p.expression(0)
		}

	case OgParserT__5:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(862)
			p.LiteralValue()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IStructTypeContext is an interface to support dynamic dispatch.
type IStructTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStructTypeContext differentiates from other interfaces.
	IsStructTypeContext()
}

type StructTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStructTypeContext() *StructTypeContext {
	var p = new(StructTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_structType
	return p
}

func (*StructTypeContext) IsStructTypeContext() {}

func NewStructTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructTypeContext {
	var p = new(StructTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_structType

	return p
}

func (s *StructTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *StructTypeContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *StructTypeContext) TemplateSpec() ITemplateSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITemplateSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITemplateSpecContext)
}

func (s *StructTypeContext) AllFieldDecl() []IFieldDeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFieldDeclContext)(nil)).Elem())
	var tst = make([]IFieldDeclContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFieldDeclContext)
		}
	}

	return tst
}

func (s *StructTypeContext) FieldDecl(i int) IFieldDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldDeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFieldDeclContext)
}

func (s *StructTypeContext) AllEos() []IEosContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEosContext)(nil)).Elem())
	var tst = make([]IEosContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IEosContext)
		}
	}

	return tst
}

func (s *StructTypeContext) Eos(i int) IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *StructTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StructTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StructTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterStructType(s)
	}
}

func (s *StructTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitStructType(s)
	}
}

func (s *StructTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case StructTypeVisitor:
		return t.VisitStructType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) StructType() (localctx IStructTypeContext) {
	localctx = NewStructTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, OgParserRULE_structType)
	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(865)
	_la = p.GetTokenStream().LA(1)

	if !(_la == OgParserT__60 || _la == OgParserT__61) {
		p.GetErrorHandler().RecoverInline(p)
	} else {
		p.GetErrorHandler().ReportMatch(p)
		p.Consume()
	}
	p.SetState(867)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(866)
			p.Match(OgParserIDENTIFIER)
		}

	}
	p.SetState(870)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 91, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(869)
			p.TemplateSpec()
		}

	}
	p.SetState(882)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 93, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(872)
			p.Match(OgParserT__5)
		}
		p.SetState(878)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(873)
					p.FieldDecl()
				}
				{
					p.SetState(874)
					p.Eos()
				}

			}
			p.SetState(880)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())
		}
		{
			p.SetState(881)
			p.Match(OgParserT__6)
		}

	}

	return localctx
}

// IFieldDeclContext is an interface to support dynamic dispatch.
type IFieldDeclContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldDeclContext differentiates from other interfaces.
	IsFieldDeclContext()
}

type FieldDeclContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldDeclContext() *FieldDeclContext {
	var p = new(FieldDeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_fieldDecl
	return p
}

func (*FieldDeclContext) IsFieldDeclContext() {}

func NewFieldDeclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldDeclContext {
	var p = new(FieldDeclContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_fieldDecl

	return p
}

func (s *FieldDeclContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldDeclContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *FieldDeclContext) 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 *FieldDeclContext) AnonymousField() IAnonymousFieldContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnonymousFieldContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnonymousFieldContext)
}

func (s *FieldDeclContext) STRING_LIT() antlr.TerminalNode {
	return s.GetToken(OgParserSTRING_LIT, 0)
}

func (s *FieldDeclContext) InlineStructMethod() IInlineStructMethodContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInlineStructMethodContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInlineStructMethodContext)
}

func (s *FieldDeclContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldDeclContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldDeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFieldDecl(s)
	}
}

func (s *FieldDeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFieldDecl(s)
	}
}

func (s *FieldDeclContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FieldDeclVisitor:
		return t.VisitFieldDecl(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) FieldDecl() (localctx IFieldDeclContext) {
	localctx = NewFieldDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, OgParserRULE_fieldDecl)

	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(895)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 96, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(889)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) {
		case 1:
			p.SetState(884)

			if !(p.noTerminatorBetween(2)) {
				panic(antlr.NewFailedPredicateException(p, "p.noTerminatorBetween(2)", ""))
			}
			{
				p.SetState(885)
				p.IdentifierList()
			}
			{
				p.SetState(886)
				p.Type_()
			}

		case 2:
			{
				p.SetState(888)
				p.AnonymousField()
			}

		}
		p.SetState(892)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 95, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(891)
				p.Match(OgParserSTRING_LIT)
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(894)
			p.InlineStructMethod()
		}

	}

	return localctx
}

// IInlineStructMethodContext is an interface to support dynamic dispatch.
type IInlineStructMethodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInlineStructMethodContext differentiates from other interfaces.
	IsInlineStructMethodContext()
}

type InlineStructMethodContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInlineStructMethodContext() *InlineStructMethodContext {
	var p = new(InlineStructMethodContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_inlineStructMethod
	return p
}

func (*InlineStructMethodContext) IsInlineStructMethodContext() {}

func NewInlineStructMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InlineStructMethodContext {
	var p = new(InlineStructMethodContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_inlineStructMethod

	return p
}

func (s *InlineStructMethodContext) GetParser() antlr.Parser { return s.parser }

func (s *InlineStructMethodContext) FunctionDecl() IFunctionDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionDeclContext)
}

func (s *InlineStructMethodContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InlineStructMethodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InlineStructMethodContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterInlineStructMethod(s)
	}
}

func (s *InlineStructMethodContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitInlineStructMethod(s)
	}
}

func (s *InlineStructMethodContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case InlineStructMethodVisitor:
		return t.VisitInlineStructMethod(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) InlineStructMethod() (localctx IInlineStructMethodContext) {
	localctx = NewInlineStructMethodContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, OgParserRULE_inlineStructMethod)
	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(898)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__15 {
		{
			p.SetState(897)
			p.Match(OgParserT__15)
		}

	}
	{
		p.SetState(900)
		p.FunctionDecl()
	}

	return localctx
}

// IAnonymousFieldContext is an interface to support dynamic dispatch.
type IAnonymousFieldContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnonymousFieldContext differentiates from other interfaces.
	IsAnonymousFieldContext()
}

type AnonymousFieldContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnonymousFieldContext() *AnonymousFieldContext {
	var p = new(AnonymousFieldContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_anonymousField
	return p
}

func (*AnonymousFieldContext) IsAnonymousFieldContext() {}

func NewAnonymousFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFieldContext {
	var p = new(AnonymousFieldContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_anonymousField

	return p
}

func (s *AnonymousFieldContext) GetParser() antlr.Parser { return s.parser }

func (s *AnonymousFieldContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *AnonymousFieldContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnonymousFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnonymousFieldContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterAnonymousField(s)
	}
}

func (s *AnonymousFieldContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitAnonymousField(s)
	}
}

func (s *AnonymousFieldContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case AnonymousFieldVisitor:
		return t.VisitAnonymousField(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) AnonymousField() (localctx IAnonymousFieldContext) {
	localctx = NewAnonymousFieldContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, OgParserRULE_anonymousField)
	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(903)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__15 {
		{
			p.SetState(902)
			p.Match(OgParserT__15)
		}

	}
	{
		p.SetState(905)
		p.TypeName()
	}

	return localctx
}

// IFunctionLitContext is an interface to support dynamic dispatch.
type IFunctionLitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionLitContext differentiates from other interfaces.
	IsFunctionLitContext()
}

type FunctionLitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionLitContext() *FunctionLitContext {
	var p = new(FunctionLitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_functionLit
	return p
}

func (*FunctionLitContext) IsFunctionLitContext() {}

func NewFunctionLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionLitContext {
	var p = new(FunctionLitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_functionLit

	return p
}

func (s *FunctionLitContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionLitContext) Function() IFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionContext)
}

func (s *FunctionLitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionLitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterFunctionLit(s)
	}
}

func (s *FunctionLitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitFunctionLit(s)
	}
}

func (s *FunctionLitContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case FunctionLitVisitor:
		return t.VisitFunctionLit(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) FunctionLit() (localctx IFunctionLitContext) {
	localctx = NewFunctionLitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, OgParserRULE_functionLit)

	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(907)
		p.Match(OgParserT__52)
	}
	{
		p.SetState(908)
		p.Function()
	}

	return localctx
}

// IPrimaryExprContext is an interface to support dynamic dispatch.
type IPrimaryExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryExprContext differentiates from other interfaces.
	IsPrimaryExprContext()
}

type PrimaryExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryExprContext() *PrimaryExprContext {
	var p = new(PrimaryExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_primaryExpr
	return p
}

func (*PrimaryExprContext) IsPrimaryExprContext() {}

func NewPrimaryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExprContext {
	var p = new(PrimaryExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_primaryExpr

	return p
}

func (s *PrimaryExprContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryExprContext) Operand() IOperandContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOperandContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOperandContext)
}

func (s *PrimaryExprContext) Conversion() IConversionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConversionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConversionContext)
}

func (s *PrimaryExprContext) PrimaryExpr() IPrimaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryExprContext)
}

func (s *PrimaryExprContext) SecondaryExpr() ISecondaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISecondaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISecondaryExprContext)
}

func (s *PrimaryExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterPrimaryExpr(s)
	}
}

func (s *PrimaryExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitPrimaryExpr(s)
	}
}

func (s *PrimaryExprContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case PrimaryExprVisitor:
		return t.VisitPrimaryExpr(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) PrimaryExpr() (localctx IPrimaryExprContext) {
	return p.primaryExpr(0)
}

func (p *OgParser) primaryExpr(_p int) (localctx IPrimaryExprContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewPrimaryExprContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IPrimaryExprContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 190
	p.EnterRecursionRule(localctx, 190, OgParserRULE_primaryExpr, _p)

	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(913)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 99, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(911)
			p.Operand()
		}

	case 2:
		{
			p.SetState(912)
			p.Conversion()
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(919)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewPrimaryExprContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, OgParserRULE_primaryExpr)
			p.SetState(915)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(916)
				p.SecondaryExpr()
			}

		}
		p.SetState(921)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext())
	}

	return localctx
}

// ISecondaryExprContext is an interface to support dynamic dispatch.
type ISecondaryExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSecondaryExprContext differentiates from other interfaces.
	IsSecondaryExprContext()
}

type SecondaryExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySecondaryExprContext() *SecondaryExprContext {
	var p = new(SecondaryExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_secondaryExpr
	return p
}

func (*SecondaryExprContext) IsSecondaryExprContext() {}

func NewSecondaryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SecondaryExprContext {
	var p = new(SecondaryExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_secondaryExpr

	return p
}

func (s *SecondaryExprContext) GetParser() antlr.Parser { return s.parser }

func (s *SecondaryExprContext) Selector() ISelectorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelectorContext)
}

func (s *SecondaryExprContext) Index() IIndexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexContext)
}

func (s *SecondaryExprContext) Slice() ISliceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISliceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISliceContext)
}

func (s *SecondaryExprContext) TypeAssertion() ITypeAssertionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAssertionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAssertionContext)
}

func (s *SecondaryExprContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

func (s *SecondaryExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SecondaryExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SecondaryExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSecondaryExpr(s)
	}
}

func (s *SecondaryExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSecondaryExpr(s)
	}
}

func (s *SecondaryExprContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SecondaryExprVisitor:
		return t.VisitSecondaryExpr(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) SecondaryExpr() (localctx ISecondaryExprContext) {
	localctx = NewSecondaryExprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, OgParserRULE_secondaryExpr)

	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(927)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(922)
			p.Selector()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(923)
			p.Index()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(924)
			p.Slice()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(925)
			p.TypeAssertion()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(926)
			p.Arguments()
		}

	}

	return localctx
}

// ISelectorContext is an interface to support dynamic dispatch.
type ISelectorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectorContext differentiates from other interfaces.
	IsSelectorContext()
}

type SelectorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelectorContext() *SelectorContext {
	var p = new(SelectorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_selector
	return p
}

func (*SelectorContext) IsSelectorContext() {}

func NewSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectorContext {
	var p = new(SelectorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_selector

	return p
}

func (s *SelectorContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectorContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *SelectorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSelector(s)
	}
}

func (s *SelectorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSelector(s)
	}
}

func (s *SelectorContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SelectorVisitor:
		return t.VisitSelector(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Selector() (localctx ISelectorContext) {
	localctx = NewSelectorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, OgParserRULE_selector)

	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(929)
		p.Match(OgParserT__8)
	}
	{
		p.SetState(930)
		p.Match(OgParserIDENTIFIER)
	}

	return localctx
}

// IIndexContext is an interface to support dynamic dispatch.
type IIndexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexContext differentiates from other interfaces.
	IsIndexContext()
}

type IndexContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexContext() *IndexContext {
	var p = new(IndexContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_index
	return p
}

func (*IndexContext) IsIndexContext() {}

func NewIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexContext {
	var p = new(IndexContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_index

	return p
}

func (s *IndexContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IndexContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterIndex(s)
	}
}

func (s *IndexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitIndex(s)
	}
}

func (s *IndexContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case IndexVisitor:
		return t.VisitIndex(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Index() (localctx IIndexContext) {
	localctx = NewIndexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, OgParserRULE_index)

	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(932)
		p.Match(OgParserT__47)
	}
	{
		p.SetState(933)
		p.expression(0)
	}
	{
		p.SetState(934)
		p.Match(OgParserT__48)
	}

	return localctx
}

// ISliceContext is an interface to support dynamic dispatch.
type ISliceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSliceContext differentiates from other interfaces.
	IsSliceContext()
}

type SliceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySliceContext() *SliceContext {
	var p = new(SliceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_slice
	return p
}

func (*SliceContext) IsSliceContext() {}

func NewSliceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SliceContext {
	var p = new(SliceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_slice

	return p
}

func (s *SliceContext) GetParser() antlr.Parser { return s.parser }

func (s *SliceContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *SliceContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SliceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SliceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SliceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterSlice(s)
	}
}

func (s *SliceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitSlice(s)
	}
}

func (s *SliceContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case SliceVisitor:
		return t.VisitSlice(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Slice() (localctx ISliceContext) {
	localctx = NewSliceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, OgParserRULE_slice)
	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(936)
		p.Match(OgParserT__47)
	}
	p.SetState(952)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) {
	case 1:
		p.SetState(938)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
			{
				p.SetState(937)
				p.expression(0)
			}

		}
		{
			p.SetState(940)
			p.Match(OgParserT__7)
		}
		p.SetState(942)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
			{
				p.SetState(941)
				p.expression(0)
			}

		}

	case 2:
		p.SetState(945)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
			{
				p.SetState(944)
				p.expression(0)
			}

		}
		{
			p.SetState(947)
			p.Match(OgParserT__7)
		}
		{
			p.SetState(948)
			p.expression(0)
		}
		{
			p.SetState(949)
			p.Match(OgParserT__7)
		}
		{
			p.SetState(950)
			p.expression(0)
		}

	}
	{
		p.SetState(954)
		p.Match(OgParserT__48)
	}

	return localctx
}

// ITypeAssertionContext is an interface to support dynamic dispatch.
type ITypeAssertionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeAssertionContext differentiates from other interfaces.
	IsTypeAssertionContext()
}

type TypeAssertionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeAssertionContext() *TypeAssertionContext {
	var p = new(TypeAssertionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_typeAssertion
	return p
}

func (*TypeAssertionContext) IsTypeAssertionContext() {}

func NewTypeAssertionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAssertionContext {
	var p = new(TypeAssertionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_typeAssertion

	return p
}

func (s *TypeAssertionContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeAssertionContext) 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 *TypeAssertionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeAssertionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeAssertionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterTypeAssertion(s)
	}
}

func (s *TypeAssertionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitTypeAssertion(s)
	}
}

func (s *TypeAssertionContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case TypeAssertionVisitor:
		return t.VisitTypeAssertion(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) TypeAssertion() (localctx ITypeAssertionContext) {
	localctx = NewTypeAssertionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, OgParserRULE_typeAssertion)

	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(956)
		p.Match(OgParserT__8)
	}
	{
		p.SetState(957)
		p.Match(OgParserT__3)
	}
	{
		p.SetState(958)
		p.Type_()
	}
	{
		p.SetState(959)
		p.Match(OgParserT__4)
	}

	return localctx
}

// IArgumentsContext is an interface to support dynamic dispatch.
type IArgumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgumentsContext differentiates from other interfaces.
	IsArgumentsContext()
}

type ArgumentsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgumentsContext() *ArgumentsContext {
	var p = new(ArgumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_arguments
	return p
}

func (*ArgumentsContext) IsArgumentsContext() {}

func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext {
	var p = new(ArgumentsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_arguments

	return p
}

func (s *ArgumentsContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgumentsContext) TemplateSpec() ITemplateSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITemplateSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITemplateSpecContext)
}

func (s *ArgumentsContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *ArgumentsContext) 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 *ArgumentsContext) RestOp() IRestOpContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRestOpContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRestOpContext)
}

func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterArguments(s)
	}
}

func (s *ArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitArguments(s)
	}
}

func (s *ArgumentsContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ArgumentsVisitor:
		return t.VisitArguments(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Arguments() (localctx IArgumentsContext) {
	localctx = NewArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, OgParserRULE_arguments)
	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(962)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__53 {
		{
			p.SetState(961)
			p.TemplateSpec()
		}

	}
	{
		p.SetState(964)
		p.Match(OgParserT__3)
	}
	p.SetState(979)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__3)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) || (((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(OgParserT__47-48))|(1<<(OgParserT__49-48))|(1<<(OgParserT__50-48))|(1<<(OgParserT__51-48))|(1<<(OgParserT__52-48))|(1<<(OgParserT__56-48))|(1<<(OgParserT__57-48))|(1<<(OgParserT__58-48))|(1<<(OgParserT__59-48))|(1<<(OgParserT__60-48))|(1<<(OgParserT__61-48))|(1<<(OgParserIDENTIFIER-48))|(1<<(OgParserINT_LIT-48))|(1<<(OgParserFLOAT_LIT-48))|(1<<(OgParserIMAGINARY_LIT-48))|(1<<(OgParserRUNE_LIT-48))|(1<<(OgParserSTRING_LIT-48)))) != 0) {
		p.SetState(971)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 108, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(965)
				p.ExpressionList()
			}

		case 2:
			{
				p.SetState(966)
				p.Type_()
			}
			p.SetState(969)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(967)
					p.Match(OgParserT__12)
				}
				{
					p.SetState(968)
					p.ExpressionList()
				}

			}

		}
		p.SetState(974)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == OgParserT__55 {
			{
				p.SetState(973)
				p.RestOp()
			}

		}
		p.SetState(977)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == OgParserT__12 {
			{
				p.SetState(976)
				p.Match(OgParserT__12)
			}

		}

	}
	{
		p.SetState(981)
		p.Match(OgParserT__4)
	}

	return localctx
}

// IMethodExprContext is an interface to support dynamic dispatch.
type IMethodExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodExprContext differentiates from other interfaces.
	IsMethodExprContext()
}

type MethodExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodExprContext() *MethodExprContext {
	var p = new(MethodExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_methodExpr
	return p
}

func (*MethodExprContext) IsMethodExprContext() {}

func NewMethodExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodExprContext {
	var p = new(MethodExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_methodExpr

	return p
}

func (s *MethodExprContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodExprContext) ReceiverType() IReceiverTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverTypeContext)
}

func (s *MethodExprContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(OgParserIDENTIFIER, 0)
}

func (s *MethodExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterMethodExpr(s)
	}
}

func (s *MethodExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitMethodExpr(s)
	}
}

func (s *MethodExprContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case MethodExprVisitor:
		return t.VisitMethodExpr(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) MethodExpr() (localctx IMethodExprContext) {
	localctx = NewMethodExprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, OgParserRULE_methodExpr)

	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(983)
		p.ReceiverType()
	}
	{
		p.SetState(984)
		p.Match(OgParserT__8)
	}
	{
		p.SetState(985)
		p.Match(OgParserIDENTIFIER)
	}

	return localctx
}

// IReceiverTypeContext is an interface to support dynamic dispatch.
type IReceiverTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReceiverTypeContext differentiates from other interfaces.
	IsReceiverTypeContext()
}

type ReceiverTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReceiverTypeContext() *ReceiverTypeContext {
	var p = new(ReceiverTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_receiverType
	return p
}

func (*ReceiverTypeContext) IsReceiverTypeContext() {}

func NewReceiverTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverTypeContext {
	var p = new(ReceiverTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_receiverType

	return p
}

func (s *ReceiverTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ReceiverTypeContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *ReceiverTypeContext) ReceiverType() IReceiverTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverTypeContext)
}

func (s *ReceiverTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReceiverTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReceiverTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterReceiverType(s)
	}
}

func (s *ReceiverTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitReceiverType(s)
	}
}

func (s *ReceiverTypeContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ReceiverTypeVisitor:
		return t.VisitReceiverType(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) ReceiverType() (localctx IReceiverTypeContext) {
	localctx = NewReceiverTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, OgParserRULE_receiverType)

	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(997)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 112, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(987)
			p.TypeName()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(988)
			p.Match(OgParserT__3)
		}
		{
			p.SetState(989)
			p.Match(OgParserT__15)
		}
		{
			p.SetState(990)
			p.TypeName()
		}
		{
			p.SetState(991)
			p.Match(OgParserT__4)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(993)
			p.Match(OgParserT__3)
		}
		{
			p.SetState(994)
			p.ReceiverType()
		}
		{
			p.SetState(995)
			p.Match(OgParserT__4)
		}

	}

	return localctx
}

// IExpressionContext is an interface to support dynamic dispatch.
type IExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionContext differentiates from other interfaces.
	IsExpressionContext()
}

type ExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionContext() *ExpressionContext {
	var p = new(ExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_expression
	return p
}

func (*ExpressionContext) IsExpressionContext() {}

func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext {
	var p = new(ExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_expression

	return p
}

func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionContext) UnaryExpr() IUnaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExprContext)
}

func (s *ExpressionContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ExpressionContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (s *ExpressionContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ExpressionVisitor:
		return t.VisitExpression(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Expression() (localctx IExpressionContext) {
	return p.expression(0)
}

func (p *OgParser) expression(_p int) (localctx IExpressionContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 208
	p.EnterRecursionRule(localctx, 208, OgParserRULE_expression, _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(1000)
		p.UnaryExpr()
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(1007)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 113, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, OgParserRULE_expression)
			p.SetState(1002)

			if !(p.Precpred(p.GetParserRuleContext(), 2)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
			}
			p.SetState(1003)
			_la = p.GetTokenStream().LA(1)

			if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__15)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__22)|(1<<OgParserT__23)|(1<<OgParserT__24)|(1<<OgParserT__25)|(1<<OgParserT__26)|(1<<OgParserT__27)|(1<<OgParserT__28)|(1<<OgParserT__29))) != 0) || (((_la-54)&-(0x1f+1)) == 0 && ((1<<uint((_la-54)))&((1<<(OgParserT__53-54))|(1<<(OgParserT__54-54))|(1<<(OgParserT__62-54))|(1<<(OgParserT__63-54))|(1<<(OgParserT__64-54))|(1<<(OgParserT__65-54))|(1<<(OgParserT__66-54))|(1<<(OgParserT__67-54)))) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
			{
				p.SetState(1004)
				p.expression(3)
			}

		}
		p.SetState(1009)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 113, p.GetParserRuleContext())
	}

	return localctx
}

// IUnaryExprContext is an interface to support dynamic dispatch.
type IUnaryExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnaryExprContext differentiates from other interfaces.
	IsUnaryExprContext()
}

type UnaryExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnaryExprContext() *UnaryExprContext {
	var p = new(UnaryExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_unaryExpr
	return p
}

func (*UnaryExprContext) IsUnaryExprContext() {}

func NewUnaryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryExprContext {
	var p = new(UnaryExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_unaryExpr

	return p
}

func (s *UnaryExprContext) GetParser() antlr.Parser { return s.parser }

func (s *UnaryExprContext) PrimaryExpr() IPrimaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryExprContext)
}

func (s *UnaryExprContext) UnaryExpr() IUnaryExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExprContext)
}

func (s *UnaryExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnaryExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnaryExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterUnaryExpr(s)
	}
}

func (s *UnaryExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitUnaryExpr(s)
	}
}

func (s *UnaryExprContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case UnaryExprVisitor:
		return t.VisitUnaryExpr(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) UnaryExpr() (localctx IUnaryExprContext) {
	localctx = NewUnaryExprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, OgParserRULE_unaryExpr)
	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(1013)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 114, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1010)
			p.primaryExpr(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1011)
		_la = p.GetTokenStream().LA(1)

		if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<OgParserT__1)|(1<<OgParserT__15)|(1<<OgParserT__17)|(1<<OgParserT__20)|(1<<OgParserT__21)|(1<<OgParserT__23)|(1<<OgParserT__28))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
		{
			p.SetState(1012)
			p.UnaryExpr()
		}

	}

	return localctx
}

// IConversionContext is an interface to support dynamic dispatch.
type IConversionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConversionContext differentiates from other interfaces.
	IsConversionContext()
}

type ConversionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConversionContext() *ConversionContext {
	var p = new(ConversionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_conversion
	return p
}

func (*ConversionContext) IsConversionContext() {}

func NewConversionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConversionContext {
	var p = new(ConversionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_conversion

	return p
}

func (s *ConversionContext) GetParser() antlr.Parser { return s.parser }

func (s *ConversionContext) 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 *ConversionContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ConversionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConversionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConversionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterConversion(s)
	}
}

func (s *ConversionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitConversion(s)
	}
}

func (s *ConversionContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case ConversionVisitor:
		return t.VisitConversion(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Conversion() (localctx IConversionContext) {
	localctx = NewConversionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, OgParserRULE_conversion)
	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(1015)
		p.Type_()
	}
	{
		p.SetState(1016)
		p.Match(OgParserT__3)
	}
	{
		p.SetState(1017)
		p.expression(0)
	}
	p.SetState(1019)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == OgParserT__12 {
		{
			p.SetState(1018)
			p.Match(OgParserT__12)
		}

	}
	{
		p.SetState(1021)
		p.Match(OgParserT__4)
	}

	return localctx
}

// IEosContext is an interface to support dynamic dispatch.
type IEosContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEosContext differentiates from other interfaces.
	IsEosContext()
}

type EosContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEosContext() *EosContext {
	var p = new(EosContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = OgParserRULE_eos
	return p
}

func (*EosContext) IsEosContext() {}

func NewEosContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EosContext {
	var p = new(EosContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = OgParserRULE_eos

	return p
}

func (s *EosContext) GetParser() antlr.Parser { return s.parser }

func (s *EosContext) EOF() antlr.TerminalNode {
	return s.GetToken(OgParserEOF, 0)
}

func (s *EosContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EosContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EosContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.EnterEos(s)
	}
}

func (s *EosContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(OgListener); ok {
		listenerT.ExitEos(s)
	}
}

func (s *EosContext) Accept(delegate antlr.ParseTreeVisitor) interface{} {
	switch t := delegate.(type) {
	case EosVisitor:
		return t.VisitEos(s, delegate)
	default:
		return delegate.VisitChildren(s, delegate)
	}
}

func (p *OgParser) Eos() (localctx IEosContext) {
	localctx = NewEosContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, OgParserRULE_eos)

	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(1027)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1023)
			p.Match(OgParserT__31)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1024)
			p.Match(OgParserEOF)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(1025)

		if !(p.lineTerminatorAhead()) {
			panic(antlr.NewFailedPredicateException(p, "p.lineTerminatorAhead()", ""))
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		p.SetState(1026)

		if !(p.GetTokenStream().LT(1).GetText() == "}") {
			panic(antlr.NewFailedPredicateException(p, "p.GetTokenStream().LT(1).GetText() == \"}\"", ""))
		}

	}

	return localctx
}

func (p *OgParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 68:
		var t *MethodSpecContext = nil
		if localctx != nil {
			t = localctx.(*MethodSpecContext)
		}
		return p.MethodSpec_Sempred(t, predIndex)

	case 70:
		var t *SignatureContext = nil
		if localctx != nil {
			t = localctx.(*SignatureContext)
		}
		return p.Signature_Sempred(t, predIndex)

	case 91:
		var t *FieldDeclContext = nil
		if localctx != nil {
			t = localctx.(*FieldDeclContext)
		}
		return p.FieldDecl_Sempred(t, predIndex)

	case 95:
		var t *PrimaryExprContext = nil
		if localctx != nil {
			t = localctx.(*PrimaryExprContext)
		}
		return p.PrimaryExpr_Sempred(t, predIndex)

	case 104:
		var t *ExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ExpressionContext)
		}
		return p.Expression_Sempred(t, predIndex)

	case 107:
		var t *EosContext = nil
		if localctx != nil {
			t = localctx.(*EosContext)
		}
		return p.Eos_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *OgParser) MethodSpec_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 0:
		return p.noTerminatorAfterParams(2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *OgParser) Signature_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 1:
		return p.noTerminatorAfterParams(1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *OgParser) FieldDecl_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 2:
		return p.noTerminatorBetween(2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *OgParser) PrimaryExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 3:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *OgParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 4:
		return p.Precpred(p.GetParserRuleContext(), 2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *OgParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 5:
		return p.lineTerminatorAhead()

	case 6:
		return p.GetTokenStream().LT(1).GetText() == "}"

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
