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

package solidity // Solidity
import (
	"fmt"
	"reflect"
	"strconv"

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

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

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

var ruleNames = []string{
	"sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", "version",
	"versionConstraint", "versionOperator", "importDirective", "importDeclaration",
	"contractDefinition", "inheritanceSpecifier", "contractPart", "stateVariableDeclaration",
	"overrideSpecifier", "usingForDeclaration", "structDefinition", "modifierDefinition",
	"functionDefinition", "functionDescriptor", "returnParameters", "modifierList",
	"modifierInvocation", "eventDefinition", "enumDefinition", "enumValue",
	"parameterList", "parameter", "eventParameterList", "eventParameter", "variableDeclaration",
	"typeName", "userDefinedTypeName", "mapping", "functionTypeName", "storageLocation",
	"stateMutability", "block", "statement", "expressionStatement", "ifStatement",
	"tryStatement", "catchClause", "whileStatement", "forStatement", "simpleStatement",
	"inlineAssemblyStatement", "doWhileStatement", "continueStatement", "breakStatement",
	"returnStatement", "throwStatement", "emitStatement", "variableDeclarationStatement",
	"variableDeclarationList", "identifierList", "elementaryTypeName", "expression",
	"primaryExpression", "expressionList", "nameValueList", "nameValue", "functionCallArguments",
	"functionCall", "tupleExpression", "typeNameExpression", "assemblyItem",
	"assemblyBlock", "assemblyExpression", "assemblyCall", "assemblyLocalDefinition",
	"assemblyAssignment", "assemblyIdentifierList", "assemblyStackAssignment",
	"labelDefinition", "assemblySwitch", "assemblyCase", "assemblyFunctionDefinition",
	"assemblyFunctionReturns", "assemblyFor", "assemblyIf", "assemblyLiteral",
	"assemblyTypedVariableList", "assemblyType", "subAssembly", "numberLiteral",
	"identifier", "hexLiteral", "stringLiteral",
}

type SolidityParser struct {
	*antlr.BaseParser
}

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

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

	return this
}

// SolidityParser tokens.
const (
	SolidityParserEOF                   = antlr.TokenEOF
	SolidityParserT__0                  = 1
	SolidityParserT__1                  = 2
	SolidityParserT__2                  = 3
	SolidityParserT__3                  = 4
	SolidityParserT__4                  = 5
	SolidityParserT__5                  = 6
	SolidityParserT__6                  = 7
	SolidityParserT__7                  = 8
	SolidityParserT__8                  = 9
	SolidityParserT__9                  = 10
	SolidityParserT__10                 = 11
	SolidityParserT__11                 = 12
	SolidityParserT__12                 = 13
	SolidityParserT__13                 = 14
	SolidityParserT__14                 = 15
	SolidityParserT__15                 = 16
	SolidityParserT__16                 = 17
	SolidityParserT__17                 = 18
	SolidityParserT__18                 = 19
	SolidityParserT__19                 = 20
	SolidityParserT__20                 = 21
	SolidityParserT__21                 = 22
	SolidityParserT__22                 = 23
	SolidityParserT__23                 = 24
	SolidityParserT__24                 = 25
	SolidityParserT__25                 = 26
	SolidityParserT__26                 = 27
	SolidityParserT__27                 = 28
	SolidityParserT__28                 = 29
	SolidityParserT__29                 = 30
	SolidityParserT__30                 = 31
	SolidityParserT__31                 = 32
	SolidityParserT__32                 = 33
	SolidityParserT__33                 = 34
	SolidityParserT__34                 = 35
	SolidityParserT__35                 = 36
	SolidityParserT__36                 = 37
	SolidityParserT__37                 = 38
	SolidityParserT__38                 = 39
	SolidityParserT__39                 = 40
	SolidityParserT__40                 = 41
	SolidityParserT__41                 = 42
	SolidityParserT__42                 = 43
	SolidityParserT__43                 = 44
	SolidityParserT__44                 = 45
	SolidityParserT__45                 = 46
	SolidityParserT__46                 = 47
	SolidityParserT__47                 = 48
	SolidityParserT__48                 = 49
	SolidityParserT__49                 = 50
	SolidityParserT__50                 = 51
	SolidityParserT__51                 = 52
	SolidityParserT__52                 = 53
	SolidityParserT__53                 = 54
	SolidityParserT__54                 = 55
	SolidityParserT__55                 = 56
	SolidityParserT__56                 = 57
	SolidityParserT__57                 = 58
	SolidityParserT__58                 = 59
	SolidityParserT__59                 = 60
	SolidityParserT__60                 = 61
	SolidityParserT__61                 = 62
	SolidityParserT__62                 = 63
	SolidityParserT__63                 = 64
	SolidityParserT__64                 = 65
	SolidityParserT__65                 = 66
	SolidityParserT__66                 = 67
	SolidityParserT__67                 = 68
	SolidityParserT__68                 = 69
	SolidityParserT__69                 = 70
	SolidityParserT__70                 = 71
	SolidityParserT__71                 = 72
	SolidityParserT__72                 = 73
	SolidityParserT__73                 = 74
	SolidityParserT__74                 = 75
	SolidityParserT__75                 = 76
	SolidityParserT__76                 = 77
	SolidityParserT__77                 = 78
	SolidityParserT__78                 = 79
	SolidityParserT__79                 = 80
	SolidityParserT__80                 = 81
	SolidityParserT__81                 = 82
	SolidityParserT__82                 = 83
	SolidityParserT__83                 = 84
	SolidityParserT__84                 = 85
	SolidityParserT__85                 = 86
	SolidityParserT__86                 = 87
	SolidityParserT__87                 = 88
	SolidityParserT__88                 = 89
	SolidityParserT__89                 = 90
	SolidityParserT__90                 = 91
	SolidityParserT__91                 = 92
	SolidityParserInt                   = 93
	SolidityParserUint                  = 94
	SolidityParserByte                  = 95
	SolidityParserFixed                 = 96
	SolidityParserUfixed                = 97
	SolidityParserBooleanLiteral        = 98
	SolidityParserDecimalNumber         = 99
	SolidityParserHexNumber             = 100
	SolidityParserNumberUnit            = 101
	SolidityParserHexLiteralFragment    = 102
	SolidityParserReservedKeyword       = 103
	SolidityParserAnonymousKeyword      = 104
	SolidityParserBreakKeyword          = 105
	SolidityParserConstantKeyword       = 106
	SolidityParserImmutableKeyword      = 107
	SolidityParserContinueKeyword       = 108
	SolidityParserLeaveKeyword          = 109
	SolidityParserExternalKeyword       = 110
	SolidityParserIndexedKeyword        = 111
	SolidityParserInternalKeyword       = 112
	SolidityParserPayableKeyword        = 113
	SolidityParserPrivateKeyword        = 114
	SolidityParserPublicKeyword         = 115
	SolidityParserVirtualKeyword        = 116
	SolidityParserPureKeyword           = 117
	SolidityParserTypeKeyword           = 118
	SolidityParserViewKeyword           = 119
	SolidityParserConstructorKeyword    = 120
	SolidityParserFallbackKeyword       = 121
	SolidityParserReceiveKeyword        = 122
	SolidityParserIdentifier            = 123
	SolidityParserStringLiteralFragment = 124
	SolidityParserVersionLiteral        = 125
	SolidityParserWS                    = 126
	SolidityParserCOMMENT               = 127
	SolidityParserLINE_COMMENT          = 128
)

// SolidityParser rules.
const (
	SolidityParserRULE_sourceUnit                   = 0
	SolidityParserRULE_pragmaDirective              = 1
	SolidityParserRULE_pragmaName                   = 2
	SolidityParserRULE_pragmaValue                  = 3
	SolidityParserRULE_version                      = 4
	SolidityParserRULE_versionConstraint            = 5
	SolidityParserRULE_versionOperator              = 6
	SolidityParserRULE_importDirective              = 7
	SolidityParserRULE_importDeclaration            = 8
	SolidityParserRULE_contractDefinition           = 9
	SolidityParserRULE_inheritanceSpecifier         = 10
	SolidityParserRULE_contractPart                 = 11
	SolidityParserRULE_stateVariableDeclaration     = 12
	SolidityParserRULE_overrideSpecifier            = 13
	SolidityParserRULE_usingForDeclaration          = 14
	SolidityParserRULE_structDefinition             = 15
	SolidityParserRULE_modifierDefinition           = 16
	SolidityParserRULE_functionDefinition           = 17
	SolidityParserRULE_functionDescriptor           = 18
	SolidityParserRULE_returnParameters             = 19
	SolidityParserRULE_modifierList                 = 20
	SolidityParserRULE_modifierInvocation           = 21
	SolidityParserRULE_eventDefinition              = 22
	SolidityParserRULE_enumDefinition               = 23
	SolidityParserRULE_enumValue                    = 24
	SolidityParserRULE_parameterList                = 25
	SolidityParserRULE_parameter                    = 26
	SolidityParserRULE_eventParameterList           = 27
	SolidityParserRULE_eventParameter               = 28
	SolidityParserRULE_variableDeclaration          = 29
	SolidityParserRULE_typeName                     = 30
	SolidityParserRULE_userDefinedTypeName          = 31
	SolidityParserRULE_mapping                      = 32
	SolidityParserRULE_functionTypeName             = 33
	SolidityParserRULE_storageLocation              = 34
	SolidityParserRULE_stateMutability              = 35
	SolidityParserRULE_block                        = 36
	SolidityParserRULE_statement                    = 37
	SolidityParserRULE_expressionStatement          = 38
	SolidityParserRULE_ifStatement                  = 39
	SolidityParserRULE_tryStatement                 = 40
	SolidityParserRULE_catchClause                  = 41
	SolidityParserRULE_whileStatement               = 42
	SolidityParserRULE_forStatement                 = 43
	SolidityParserRULE_simpleStatement              = 44
	SolidityParserRULE_inlineAssemblyStatement      = 45
	SolidityParserRULE_doWhileStatement             = 46
	SolidityParserRULE_continueStatement            = 47
	SolidityParserRULE_breakStatement               = 48
	SolidityParserRULE_returnStatement              = 49
	SolidityParserRULE_throwStatement               = 50
	SolidityParserRULE_emitStatement                = 51
	SolidityParserRULE_variableDeclarationStatement = 52
	SolidityParserRULE_variableDeclarationList      = 53
	SolidityParserRULE_identifierList               = 54
	SolidityParserRULE_elementaryTypeName           = 55
	SolidityParserRULE_expression                   = 56
	SolidityParserRULE_primaryExpression            = 57
	SolidityParserRULE_expressionList               = 58
	SolidityParserRULE_nameValueList                = 59
	SolidityParserRULE_nameValue                    = 60
	SolidityParserRULE_functionCallArguments        = 61
	SolidityParserRULE_functionCall                 = 62
	SolidityParserRULE_tupleExpression              = 63
	SolidityParserRULE_typeNameExpression           = 64
	SolidityParserRULE_assemblyItem                 = 65
	SolidityParserRULE_assemblyBlock                = 66
	SolidityParserRULE_assemblyExpression           = 67
	SolidityParserRULE_assemblyCall                 = 68
	SolidityParserRULE_assemblyLocalDefinition      = 69
	SolidityParserRULE_assemblyAssignment           = 70
	SolidityParserRULE_assemblyIdentifierList       = 71
	SolidityParserRULE_assemblyStackAssignment      = 72
	SolidityParserRULE_labelDefinition              = 73
	SolidityParserRULE_assemblySwitch               = 74
	SolidityParserRULE_assemblyCase                 = 75
	SolidityParserRULE_assemblyFunctionDefinition   = 76
	SolidityParserRULE_assemblyFunctionReturns      = 77
	SolidityParserRULE_assemblyFor                  = 78
	SolidityParserRULE_assemblyIf                   = 79
	SolidityParserRULE_assemblyLiteral              = 80
	SolidityParserRULE_assemblyTypedVariableList    = 81
	SolidityParserRULE_assemblyType                 = 82
	SolidityParserRULE_subAssembly                  = 83
	SolidityParserRULE_numberLiteral                = 84
	SolidityParserRULE_identifier                   = 85
	SolidityParserRULE_hexLiteral                   = 86
	SolidityParserRULE_stringLiteral                = 87
)

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

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

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

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

func NewEmptySourceUnitContext() *SourceUnitContext {
	var p = new(SourceUnitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_sourceUnit
	return p
}

func (*SourceUnitContext) IsSourceUnitContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_sourceUnit

	return p
}

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

func (s *SourceUnitContext) EOF() antlr.TerminalNode {
	return s.GetToken(SolidityParserEOF, 0)
}

func (s *SourceUnitContext) AllPragmaDirective() []IPragmaDirectiveContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPragmaDirectiveContext)(nil)).Elem())
	var tst = make([]IPragmaDirectiveContext, len(ts))

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

	return tst
}

func (s *SourceUnitContext) PragmaDirective(i int) IPragmaDirectiveContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragmaDirectiveContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPragmaDirectiveContext)
}

func (s *SourceUnitContext) AllImportDirective() []IImportDirectiveContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportDirectiveContext)(nil)).Elem())
	var tst = make([]IImportDirectiveContext, len(ts))

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

	return tst
}

func (s *SourceUnitContext) ImportDirective(i int) IImportDirectiveContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportDirectiveContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IImportDirectiveContext)
}

func (s *SourceUnitContext) AllStructDefinition() []IStructDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStructDefinitionContext)(nil)).Elem())
	var tst = make([]IStructDefinitionContext, len(ts))

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

	return tst
}

func (s *SourceUnitContext) StructDefinition(i int) IStructDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStructDefinitionContext)
}

func (s *SourceUnitContext) AllEnumDefinition() []IEnumDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumDefinitionContext)(nil)).Elem())
	var tst = make([]IEnumDefinitionContext, len(ts))

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

	return tst
}

func (s *SourceUnitContext) EnumDefinition(i int) IEnumDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumDefinitionContext)
}

func (s *SourceUnitContext) AllContractDefinition() []IContractDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IContractDefinitionContext)(nil)).Elem())
	var tst = make([]IContractDefinitionContext, len(ts))

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

	return tst
}

func (s *SourceUnitContext) ContractDefinition(i int) IContractDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IContractDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IContractDefinitionContext)
}

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

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

func (s *SourceUnitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterSourceUnit(s)
	}
}

func (s *SourceUnitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitSourceUnit(s)
	}
}

func (p *SolidityParser) SourceUnit() (localctx ISourceUnitContext) {
	this := p
	_ = this

	localctx = NewSourceUnitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, SolidityParserRULE_sourceUnit)
	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(183)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-1)&-(0x1f+1)) == 0 && ((1<<uint((_la-1)))&((1<<(SolidityParserT__0-1))|(1<<(SolidityParserT__9-1))|(1<<(SolidityParserT__16-1))|(1<<(SolidityParserT__17-1))|(1<<(SolidityParserT__18-1))|(1<<(SolidityParserT__19-1))|(1<<(SolidityParserT__26-1))|(1<<(SolidityParserT__31-1)))) != 0 {
		p.SetState(181)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SolidityParserT__0:
			{
				p.SetState(176)
				p.PragmaDirective()
			}

		case SolidityParserT__9:
			{
				p.SetState(177)
				p.ImportDirective()
			}

		case SolidityParserT__26:
			{
				p.SetState(178)
				p.StructDefinition()
			}

		case SolidityParserT__31:
			{
				p.SetState(179)
				p.EnumDefinition()
			}

		case SolidityParserT__16, SolidityParserT__17, SolidityParserT__18, SolidityParserT__19:
			{
				p.SetState(180)
				p.ContractDefinition()
			}

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

		p.SetState(185)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(186)
		p.Match(SolidityParserEOF)
	}

	return localctx
}

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

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

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

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

func NewEmptyPragmaDirectiveContext() *PragmaDirectiveContext {
	var p = new(PragmaDirectiveContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_pragmaDirective
	return p
}

func (*PragmaDirectiveContext) IsPragmaDirectiveContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_pragmaDirective

	return p
}

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

func (s *PragmaDirectiveContext) PragmaName() IPragmaNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragmaNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragmaNameContext)
}

func (s *PragmaDirectiveContext) PragmaValue() IPragmaValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragmaValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragmaValueContext)
}

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

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

func (s *PragmaDirectiveContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterPragmaDirective(s)
	}
}

func (s *PragmaDirectiveContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitPragmaDirective(s)
	}
}

func (p *SolidityParser) PragmaDirective() (localctx IPragmaDirectiveContext) {
	this := p
	_ = this

	localctx = NewPragmaDirectiveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, SolidityParserRULE_pragmaDirective)

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

	defer func() {
		if err := recover(); err != 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(188)
		p.Match(SolidityParserT__0)
	}
	{
		p.SetState(189)
		p.PragmaName()
	}
	{
		p.SetState(190)
		p.PragmaValue()
	}
	{
		p.SetState(191)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyPragmaNameContext() *PragmaNameContext {
	var p = new(PragmaNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_pragmaName
	return p
}

func (*PragmaNameContext) IsPragmaNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_pragmaName

	return p
}

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

func (s *PragmaNameContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *PragmaNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterPragmaName(s)
	}
}

func (s *PragmaNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitPragmaName(s)
	}
}

func (p *SolidityParser) PragmaName() (localctx IPragmaNameContext) {
	this := p
	_ = this

	localctx = NewPragmaNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, SolidityParserRULE_pragmaName)

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

	defer func() {
		if err := recover(); err != 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(193)
		p.Identifier()
	}

	return localctx
}

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

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

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

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

func NewEmptyPragmaValueContext() *PragmaValueContext {
	var p = new(PragmaValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_pragmaValue
	return p
}

func (*PragmaValueContext) IsPragmaValueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_pragmaValue

	return p
}

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

func (s *PragmaValueContext) Version() IVersionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVersionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVersionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *PragmaValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterPragmaValue(s)
	}
}

func (s *PragmaValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitPragmaValue(s)
	}
}

func (p *SolidityParser) PragmaValue() (localctx IPragmaValueContext) {
	this := p
	_ = this

	localctx = NewPragmaValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, SolidityParserRULE_pragmaValue)

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

	defer func() {
		if err := recover(); err != 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(197)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(195)
			p.Version()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(196)
			p.expression(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVersionContext() *VersionContext {
	var p = new(VersionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_version
	return p
}

func (*VersionContext) IsVersionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_version

	return p
}

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

func (s *VersionContext) AllVersionConstraint() []IVersionConstraintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVersionConstraintContext)(nil)).Elem())
	var tst = make([]IVersionConstraintContext, len(ts))

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

	return tst
}

func (s *VersionContext) VersionConstraint(i int) IVersionConstraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVersionConstraintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVersionConstraintContext)
}

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

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

func (s *VersionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVersion(s)
	}
}

func (s *VersionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVersion(s)
	}
}

func (p *SolidityParser) Version() (localctx IVersionContext) {
	this := p
	_ = this

	localctx = NewVersionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, SolidityParserRULE_version)
	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(199)
		p.VersionConstraint()
	}
	p.SetState(201)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__2)|(1<<SolidityParserT__3)|(1<<SolidityParserT__4)|(1<<SolidityParserT__5)|(1<<SolidityParserT__6)|(1<<SolidityParserT__7)|(1<<SolidityParserT__8))) != 0) || _la == SolidityParserVersionLiteral {
		{
			p.SetState(200)
			p.VersionConstraint()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVersionConstraintContext() *VersionConstraintContext {
	var p = new(VersionConstraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_versionConstraint
	return p
}

func (*VersionConstraintContext) IsVersionConstraintContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_versionConstraint

	return p
}

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

func (s *VersionConstraintContext) VersionLiteral() antlr.TerminalNode {
	return s.GetToken(SolidityParserVersionLiteral, 0)
}

func (s *VersionConstraintContext) VersionOperator() IVersionOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVersionOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVersionOperatorContext)
}

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

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

func (s *VersionConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVersionConstraint(s)
	}
}

func (s *VersionConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVersionConstraint(s)
	}
}

func (p *SolidityParser) VersionConstraint() (localctx IVersionConstraintContext) {
	this := p
	_ = this

	localctx = NewVersionConstraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, SolidityParserRULE_versionConstraint)
	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(204)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__2)|(1<<SolidityParserT__3)|(1<<SolidityParserT__4)|(1<<SolidityParserT__5)|(1<<SolidityParserT__6)|(1<<SolidityParserT__7)|(1<<SolidityParserT__8))) != 0 {
		{
			p.SetState(203)
			p.VersionOperator()
		}

	}
	{
		p.SetState(206)
		p.Match(SolidityParserVersionLiteral)
	}

	return localctx
}

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

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

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

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

func NewEmptyVersionOperatorContext() *VersionOperatorContext {
	var p = new(VersionOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_versionOperator
	return p
}

func (*VersionOperatorContext) IsVersionOperatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_versionOperator

	return p
}

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

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

func (s *VersionOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVersionOperator(s)
	}
}

func (s *VersionOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVersionOperator(s)
	}
}

func (p *SolidityParser) VersionOperator() (localctx IVersionOperatorContext) {
	this := p
	_ = this

	localctx = NewVersionOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, SolidityParserRULE_versionOperator)
	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(208)
		_la = p.GetTokenStream().LA(1)

		if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__2)|(1<<SolidityParserT__3)|(1<<SolidityParserT__4)|(1<<SolidityParserT__5)|(1<<SolidityParserT__6)|(1<<SolidityParserT__7)|(1<<SolidityParserT__8))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyImportDirectiveContext() *ImportDirectiveContext {
	var p = new(ImportDirectiveContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_importDirective
	return p
}

func (*ImportDirectiveContext) IsImportDirectiveContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_importDirective

	return p
}

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

func (s *ImportDirectiveContext) StringLiteralFragment() antlr.TerminalNode {
	return s.GetToken(SolidityParserStringLiteralFragment, 0)
}

func (s *ImportDirectiveContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *ImportDirectiveContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *ImportDirectiveContext) AllImportDeclaration() []IImportDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportDeclarationContext)(nil)).Elem())
	var tst = make([]IImportDeclarationContext, len(ts))

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

	return tst
}

func (s *ImportDirectiveContext) ImportDeclaration(i int) IImportDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IImportDeclarationContext)
}

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

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

func (s *ImportDirectiveContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterImportDirective(s)
	}
}

func (s *ImportDirectiveContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitImportDirective(s)
	}
}

func (p *SolidityParser) ImportDirective() (localctx IImportDirectiveContext) {
	this := p
	_ = this

	localctx = NewImportDirectiveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, SolidityParserRULE_importDirective)
	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(244)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(210)
			p.Match(SolidityParserT__9)
		}
		{
			p.SetState(211)
			p.Match(SolidityParserStringLiteralFragment)
		}
		p.SetState(214)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__10 {
			{
				p.SetState(212)
				p.Match(SolidityParserT__10)
			}
			{
				p.SetState(213)
				p.Identifier()
			}

		}
		{
			p.SetState(216)
			p.Match(SolidityParserT__1)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(217)
			p.Match(SolidityParserT__9)
		}
		p.SetState(220)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SolidityParserT__11:
			{
				p.SetState(218)
				p.Match(SolidityParserT__11)
			}

		case SolidityParserT__12, SolidityParserT__39, SolidityParserT__51, SolidityParserIdentifier:
			{
				p.SetState(219)
				p.Identifier()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		p.SetState(224)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__10 {
			{
				p.SetState(222)
				p.Match(SolidityParserT__10)
			}
			{
				p.SetState(223)
				p.Identifier()
			}

		}
		{
			p.SetState(226)
			p.Match(SolidityParserT__12)
		}
		{
			p.SetState(227)
			p.Match(SolidityParserStringLiteralFragment)
		}
		{
			p.SetState(228)
			p.Match(SolidityParserT__1)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(229)
			p.Match(SolidityParserT__9)
		}
		{
			p.SetState(230)
			p.Match(SolidityParserT__13)
		}
		{
			p.SetState(231)
			p.ImportDeclaration()
		}
		p.SetState(236)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__14 {
			{
				p.SetState(232)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(233)
				p.ImportDeclaration()
			}

			p.SetState(238)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(239)
			p.Match(SolidityParserT__15)
		}
		{
			p.SetState(240)
			p.Match(SolidityParserT__12)
		}
		{
			p.SetState(241)
			p.Match(SolidityParserStringLiteralFragment)
		}
		{
			p.SetState(242)
			p.Match(SolidityParserT__1)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyImportDeclarationContext() *ImportDeclarationContext {
	var p = new(ImportDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_importDeclaration
	return p
}

func (*ImportDeclarationContext) IsImportDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_importDeclaration

	return p
}

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

func (s *ImportDeclarationContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *ImportDeclarationContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *ImportDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterImportDeclaration(s)
	}
}

func (s *ImportDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitImportDeclaration(s)
	}
}

func (p *SolidityParser) ImportDeclaration() (localctx IImportDeclarationContext) {
	this := p
	_ = this

	localctx = NewImportDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, SolidityParserRULE_importDeclaration)
	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(246)
		p.Identifier()
	}
	p.SetState(249)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__10 {
		{
			p.SetState(247)
			p.Match(SolidityParserT__10)
		}
		{
			p.SetState(248)
			p.Identifier()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyContractDefinitionContext() *ContractDefinitionContext {
	var p = new(ContractDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_contractDefinition
	return p
}

func (*ContractDefinitionContext) IsContractDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_contractDefinition

	return p
}

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

func (s *ContractDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *ContractDefinitionContext) AllInheritanceSpecifier() []IInheritanceSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInheritanceSpecifierContext)(nil)).Elem())
	var tst = make([]IInheritanceSpecifierContext, len(ts))

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

	return tst
}

func (s *ContractDefinitionContext) InheritanceSpecifier(i int) IInheritanceSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInheritanceSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInheritanceSpecifierContext)
}

func (s *ContractDefinitionContext) AllContractPart() []IContractPartContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IContractPartContext)(nil)).Elem())
	var tst = make([]IContractPartContext, len(ts))

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

	return tst
}

func (s *ContractDefinitionContext) ContractPart(i int) IContractPartContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IContractPartContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IContractPartContext)
}

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

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

func (s *ContractDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterContractDefinition(s)
	}
}

func (s *ContractDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitContractDefinition(s)
	}
}

func (p *SolidityParser) ContractDefinition() (localctx IContractDefinitionContext) {
	this := p
	_ = this

	localctx = NewContractDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, SolidityParserRULE_contractDefinition)
	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(252)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__16 {
		{
			p.SetState(251)
			p.Match(SolidityParserT__16)
		}

	}
	{
		p.SetState(254)
		_la = p.GetTokenStream().LA(1)

		if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__17)|(1<<SolidityParserT__18)|(1<<SolidityParserT__19))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(255)
		p.Identifier()
	}
	p.SetState(265)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__20 {
		{
			p.SetState(256)
			p.Match(SolidityParserT__20)
		}
		{
			p.SetState(257)
			p.InheritanceSpecifier()
		}
		p.SetState(262)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__14 {
			{
				p.SetState(258)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(259)
				p.InheritanceSpecifier()
			}

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

	}
	{
		p.SetState(267)
		p.Match(SolidityParserT__13)
	}
	p.SetState(271)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__12)|(1<<SolidityParserT__24)|(1<<SolidityParserT__26)|(1<<SolidityParserT__27)|(1<<SolidityParserT__28)|(1<<SolidityParserT__30))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(SolidityParserT__31-32))|(1<<(SolidityParserT__35-32))|(1<<(SolidityParserT__39-32))|(1<<(SolidityParserT__50-32))|(1<<(SolidityParserT__51-32))|(1<<(SolidityParserT__52-32))|(1<<(SolidityParserT__53-32))|(1<<(SolidityParserT__54-32)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserConstructorKeyword-93))|(1<<(SolidityParserFallbackKeyword-93))|(1<<(SolidityParserReceiveKeyword-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
		{
			p.SetState(268)
			p.ContractPart()
		}

		p.SetState(273)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(274)
		p.Match(SolidityParserT__15)
	}

	return localctx
}

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

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

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

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

func NewEmptyInheritanceSpecifierContext() *InheritanceSpecifierContext {
	var p = new(InheritanceSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_inheritanceSpecifier
	return p
}

func (*InheritanceSpecifierContext) IsInheritanceSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_inheritanceSpecifier

	return p
}

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

func (s *InheritanceSpecifierContext) UserDefinedTypeName() IUserDefinedTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserDefinedTypeNameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *InheritanceSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterInheritanceSpecifier(s)
	}
}

func (s *InheritanceSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitInheritanceSpecifier(s)
	}
}

func (p *SolidityParser) InheritanceSpecifier() (localctx IInheritanceSpecifierContext) {
	this := p
	_ = this

	localctx = NewInheritanceSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, SolidityParserRULE_inheritanceSpecifier)
	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(276)
		p.UserDefinedTypeName()
	}
	p.SetState(282)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__21 {
		{
			p.SetState(277)
			p.Match(SolidityParserT__21)
		}
		p.SetState(279)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
			{
				p.SetState(278)
				p.ExpressionList()
			}

		}
		{
			p.SetState(281)
			p.Match(SolidityParserT__22)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyContractPartContext() *ContractPartContext {
	var p = new(ContractPartContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_contractPart
	return p
}

func (*ContractPartContext) IsContractPartContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_contractPart

	return p
}

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

func (s *ContractPartContext) StateVariableDeclaration() IStateVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStateVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStateVariableDeclarationContext)
}

func (s *ContractPartContext) UsingForDeclaration() IUsingForDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUsingForDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUsingForDeclarationContext)
}

func (s *ContractPartContext) StructDefinition() IStructDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructDefinitionContext)
}

func (s *ContractPartContext) ModifierDefinition() IModifierDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModifierDefinitionContext)
}

func (s *ContractPartContext) FunctionDefinition() IFunctionDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionDefinitionContext)
}

func (s *ContractPartContext) EventDefinition() IEventDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEventDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEventDefinitionContext)
}

func (s *ContractPartContext) EnumDefinition() IEnumDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDefinitionContext)
}

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

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

func (s *ContractPartContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterContractPart(s)
	}
}

func (s *ContractPartContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitContractPart(s)
	}
}

func (p *SolidityParser) ContractPart() (localctx IContractPartContext) {
	this := p
	_ = this

	localctx = NewContractPartContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, SolidityParserRULE_contractPart)

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

	defer func() {
		if err := recover(); err != 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(291)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(284)
			p.StateVariableDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(285)
			p.UsingForDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(286)
			p.StructDefinition()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(287)
			p.ModifierDefinition()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(288)
			p.FunctionDefinition()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(289)
			p.EventDefinition()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(290)
			p.EnumDefinition()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyStateVariableDeclarationContext() *StateVariableDeclarationContext {
	var p = new(StateVariableDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_stateVariableDeclaration
	return p
}

func (*StateVariableDeclarationContext) IsStateVariableDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_stateVariableDeclaration

	return p
}

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

func (s *StateVariableDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *StateVariableDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *StateVariableDeclarationContext) AllPublicKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserPublicKeyword)
}

func (s *StateVariableDeclarationContext) PublicKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserPublicKeyword, i)
}

func (s *StateVariableDeclarationContext) AllInternalKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserInternalKeyword)
}

func (s *StateVariableDeclarationContext) InternalKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserInternalKeyword, i)
}

func (s *StateVariableDeclarationContext) AllPrivateKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserPrivateKeyword)
}

func (s *StateVariableDeclarationContext) PrivateKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserPrivateKeyword, i)
}

func (s *StateVariableDeclarationContext) AllConstantKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserConstantKeyword)
}

func (s *StateVariableDeclarationContext) ConstantKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserConstantKeyword, i)
}

func (s *StateVariableDeclarationContext) AllImmutableKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserImmutableKeyword)
}

func (s *StateVariableDeclarationContext) ImmutableKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserImmutableKeyword, i)
}

func (s *StateVariableDeclarationContext) AllOverrideSpecifier() []IOverrideSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem())
	var tst = make([]IOverrideSpecifierContext, len(ts))

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

	return tst
}

func (s *StateVariableDeclarationContext) OverrideSpecifier(i int) IOverrideSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOverrideSpecifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *StateVariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterStateVariableDeclaration(s)
	}
}

func (s *StateVariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitStateVariableDeclaration(s)
	}
}

func (p *SolidityParser) StateVariableDeclaration() (localctx IStateVariableDeclarationContext) {
	this := p
	_ = this

	localctx = NewStateVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, SolidityParserRULE_stateVariableDeclaration)
	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(293)
		p.typeName(0)
	}
	p.SetState(302)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SolidityParserT__23 || (((_la-106)&-(0x1f+1)) == 0 && ((1<<uint((_la-106)))&((1<<(SolidityParserConstantKeyword-106))|(1<<(SolidityParserImmutableKeyword-106))|(1<<(SolidityParserInternalKeyword-106))|(1<<(SolidityParserPrivateKeyword-106))|(1<<(SolidityParserPublicKeyword-106)))) != 0) {
		p.SetState(300)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SolidityParserPublicKeyword:
			{
				p.SetState(294)
				p.Match(SolidityParserPublicKeyword)
			}

		case SolidityParserInternalKeyword:
			{
				p.SetState(295)
				p.Match(SolidityParserInternalKeyword)
			}

		case SolidityParserPrivateKeyword:
			{
				p.SetState(296)
				p.Match(SolidityParserPrivateKeyword)
			}

		case SolidityParserConstantKeyword:
			{
				p.SetState(297)
				p.Match(SolidityParserConstantKeyword)
			}

		case SolidityParserImmutableKeyword:
			{
				p.SetState(298)
				p.Match(SolidityParserImmutableKeyword)
			}

		case SolidityParserT__23:
			{
				p.SetState(299)
				p.OverrideSpecifier()
			}

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

		p.SetState(304)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(305)
		p.Identifier()
	}
	p.SetState(308)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__8 {
		{
			p.SetState(306)
			p.Match(SolidityParserT__8)
		}
		{
			p.SetState(307)
			p.expression(0)
		}

	}
	{
		p.SetState(310)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyOverrideSpecifierContext() *OverrideSpecifierContext {
	var p = new(OverrideSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_overrideSpecifier
	return p
}

func (*OverrideSpecifierContext) IsOverrideSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_overrideSpecifier

	return p
}

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

func (s *OverrideSpecifierContext) AllUserDefinedTypeName() []IUserDefinedTypeNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem())
	var tst = make([]IUserDefinedTypeNameContext, len(ts))

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

	return tst
}

func (s *OverrideSpecifierContext) UserDefinedTypeName(i int) IUserDefinedTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUserDefinedTypeNameContext)
}

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

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

func (s *OverrideSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterOverrideSpecifier(s)
	}
}

func (s *OverrideSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitOverrideSpecifier(s)
	}
}

func (p *SolidityParser) OverrideSpecifier() (localctx IOverrideSpecifierContext) {
	this := p
	_ = this

	localctx = NewOverrideSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, SolidityParserRULE_overrideSpecifier)
	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(312)
		p.Match(SolidityParserT__23)
	}
	p.SetState(324)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(313)
			p.Match(SolidityParserT__21)
		}
		{
			p.SetState(314)
			p.UserDefinedTypeName()
		}
		p.SetState(319)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__14 {
			{
				p.SetState(315)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(316)
				p.UserDefinedTypeName()
			}

			p.SetState(321)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(322)
			p.Match(SolidityParserT__22)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyUsingForDeclarationContext() *UsingForDeclarationContext {
	var p = new(UsingForDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_usingForDeclaration
	return p
}

func (*UsingForDeclarationContext) IsUsingForDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_usingForDeclaration

	return p
}

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

func (s *UsingForDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *UsingForDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

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

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

func (s *UsingForDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterUsingForDeclaration(s)
	}
}

func (s *UsingForDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitUsingForDeclaration(s)
	}
}

func (p *SolidityParser) UsingForDeclaration() (localctx IUsingForDeclarationContext) {
	this := p
	_ = this

	localctx = NewUsingForDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, SolidityParserRULE_usingForDeclaration)

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

	defer func() {
		if err := recover(); err != 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(326)
		p.Match(SolidityParserT__24)
	}
	{
		p.SetState(327)
		p.Identifier()
	}
	{
		p.SetState(328)
		p.Match(SolidityParserT__25)
	}
	p.SetState(331)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__11:
		{
			p.SetState(329)
			p.Match(SolidityParserT__11)
		}

	case SolidityParserT__12, SolidityParserT__28, SolidityParserT__35, SolidityParserT__39, SolidityParserT__50, SolidityParserT__51, SolidityParserT__52, SolidityParserT__53, SolidityParserT__54, SolidityParserInt, SolidityParserUint, SolidityParserByte, SolidityParserFixed, SolidityParserUfixed, SolidityParserIdentifier:
		{
			p.SetState(330)
			p.typeName(0)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(333)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyStructDefinitionContext() *StructDefinitionContext {
	var p = new(StructDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_structDefinition
	return p
}

func (*StructDefinitionContext) IsStructDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_structDefinition

	return p
}

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

func (s *StructDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *StructDefinitionContext) AllVariableDeclaration() []IVariableDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem())
	var tst = make([]IVariableDeclarationContext, len(ts))

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

	return tst
}

func (s *StructDefinitionContext) VariableDeclaration(i int) IVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationContext)
}

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

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

func (s *StructDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterStructDefinition(s)
	}
}

func (s *StructDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitStructDefinition(s)
	}
}

func (p *SolidityParser) StructDefinition() (localctx IStructDefinitionContext) {
	this := p
	_ = this

	localctx = NewStructDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, SolidityParserRULE_structDefinition)
	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(335)
		p.Match(SolidityParserT__26)
	}
	{
		p.SetState(336)
		p.Identifier()
	}
	{
		p.SetState(337)
		p.Match(SolidityParserT__13)
	}
	p.SetState(348)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
		{
			p.SetState(338)
			p.VariableDeclaration()
		}
		{
			p.SetState(339)
			p.Match(SolidityParserT__1)
		}
		p.SetState(345)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
			{
				p.SetState(340)
				p.VariableDeclaration()
			}
			{
				p.SetState(341)
				p.Match(SolidityParserT__1)
			}

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

	}
	{
		p.SetState(350)
		p.Match(SolidityParserT__15)
	}

	return localctx
}

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

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

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

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

func NewEmptyModifierDefinitionContext() *ModifierDefinitionContext {
	var p = new(ModifierDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_modifierDefinition
	return p
}

func (*ModifierDefinitionContext) IsModifierDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_modifierDefinition

	return p
}

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

func (s *ModifierDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ModifierDefinitionContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *ModifierDefinitionContext) AllVirtualKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserVirtualKeyword)
}

func (s *ModifierDefinitionContext) VirtualKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserVirtualKeyword, i)
}

func (s *ModifierDefinitionContext) AllOverrideSpecifier() []IOverrideSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem())
	var tst = make([]IOverrideSpecifierContext, len(ts))

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

	return tst
}

func (s *ModifierDefinitionContext) OverrideSpecifier(i int) IOverrideSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOverrideSpecifierContext)
}

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

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

func (s *ModifierDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterModifierDefinition(s)
	}
}

func (s *ModifierDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitModifierDefinition(s)
	}
}

func (p *SolidityParser) ModifierDefinition() (localctx IModifierDefinitionContext) {
	this := p
	_ = this

	localctx = NewModifierDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, SolidityParserRULE_modifierDefinition)
	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(352)
		p.Match(SolidityParserT__27)
	}
	{
		p.SetState(353)
		p.Identifier()
	}
	p.SetState(355)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__21 {
		{
			p.SetState(354)
			p.ParameterList()
		}

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

	for _la == SolidityParserT__23 || _la == SolidityParserVirtualKeyword {
		p.SetState(359)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SolidityParserVirtualKeyword:
			{
				p.SetState(357)
				p.Match(SolidityParserVirtualKeyword)
			}

		case SolidityParserT__23:
			{
				p.SetState(358)
				p.OverrideSpecifier()
			}

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

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

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__1:
		{
			p.SetState(364)
			p.Match(SolidityParserT__1)
		}

	case SolidityParserT__13:
		{
			p.SetState(365)
			p.Block()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFunctionDefinitionContext() *FunctionDefinitionContext {
	var p = new(FunctionDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_functionDefinition
	return p
}

func (*FunctionDefinitionContext) IsFunctionDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_functionDefinition

	return p
}

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

func (s *FunctionDefinitionContext) FunctionDescriptor() IFunctionDescriptorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionDescriptorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionDescriptorContext)
}

func (s *FunctionDefinitionContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *FunctionDefinitionContext) ModifierList() IModifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModifierListContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *FunctionDefinitionContext) ReturnParameters() IReturnParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnParametersContext)
}

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

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

func (s *FunctionDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterFunctionDefinition(s)
	}
}

func (s *FunctionDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitFunctionDefinition(s)
	}
}

func (p *SolidityParser) FunctionDefinition() (localctx IFunctionDefinitionContext) {
	this := p
	_ = this

	localctx = NewFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, SolidityParserRULE_functionDefinition)
	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(368)
		p.FunctionDescriptor()
	}
	{
		p.SetState(369)
		p.ParameterList()
	}
	{
		p.SetState(370)
		p.ModifierList()
	}
	p.SetState(372)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__29 {
		{
			p.SetState(371)
			p.ReturnParameters()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__1:
		{
			p.SetState(374)
			p.Match(SolidityParserT__1)
		}

	case SolidityParserT__13:
		{
			p.SetState(375)
			p.Block()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFunctionDescriptorContext() *FunctionDescriptorContext {
	var p = new(FunctionDescriptorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_functionDescriptor
	return p
}

func (*FunctionDescriptorContext) IsFunctionDescriptorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_functionDescriptor

	return p
}

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

func (s *FunctionDescriptorContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *FunctionDescriptorContext) ReceiveKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserReceiveKeyword, 0)
}

func (s *FunctionDescriptorContext) FallbackKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserFallbackKeyword, 0)
}

func (s *FunctionDescriptorContext) ConstructorKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserConstructorKeyword, 0)
}

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

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

func (s *FunctionDescriptorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterFunctionDescriptor(s)
	}
}

func (s *FunctionDescriptorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitFunctionDescriptor(s)
	}
}

func (p *SolidityParser) FunctionDescriptor() (localctx IFunctionDescriptorContext) {
	this := p
	_ = this

	localctx = NewFunctionDescriptorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, SolidityParserRULE_functionDescriptor)

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

	defer func() {
		if err := recover(); err != 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(387)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__28:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(378)
			p.Match(SolidityParserT__28)
		}
		p.SetState(382)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SolidityParserT__12, SolidityParserT__39, SolidityParserT__51, SolidityParserIdentifier:
			{
				p.SetState(379)
				p.Identifier()
			}

		case SolidityParserReceiveKeyword:
			{
				p.SetState(380)
				p.Match(SolidityParserReceiveKeyword)
			}

		case SolidityParserFallbackKeyword:
			{
				p.SetState(381)
				p.Match(SolidityParserFallbackKeyword)
			}

		case SolidityParserT__21:

		default:
		}

	case SolidityParserConstructorKeyword:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(384)
			p.Match(SolidityParserConstructorKeyword)
		}

	case SolidityParserFallbackKeyword:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(385)
			p.Match(SolidityParserFallbackKeyword)
		}

	case SolidityParserReceiveKeyword:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(386)
			p.Match(SolidityParserReceiveKeyword)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyReturnParametersContext() *ReturnParametersContext {
	var p = new(ReturnParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_returnParameters
	return p
}

func (*ReturnParametersContext) IsReturnParametersContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_returnParameters

	return p
}

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

func (s *ReturnParametersContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

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

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

func (s *ReturnParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterReturnParameters(s)
	}
}

func (s *ReturnParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitReturnParameters(s)
	}
}

func (p *SolidityParser) ReturnParameters() (localctx IReturnParametersContext) {
	this := p
	_ = this

	localctx = NewReturnParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, SolidityParserRULE_returnParameters)

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

	defer func() {
		if err := recover(); err != 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(389)
		p.Match(SolidityParserT__29)
	}
	{
		p.SetState(390)
		p.ParameterList()
	}

	return localctx
}

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

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

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

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

func NewEmptyModifierListContext() *ModifierListContext {
	var p = new(ModifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_modifierList
	return p
}

func (*ModifierListContext) IsModifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_modifierList

	return p
}

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

func (s *ModifierListContext) AllModifierInvocation() []IModifierInvocationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModifierInvocationContext)(nil)).Elem())
	var tst = make([]IModifierInvocationContext, len(ts))

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

	return tst
}

func (s *ModifierListContext) ModifierInvocation(i int) IModifierInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierInvocationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModifierInvocationContext)
}

func (s *ModifierListContext) AllStateMutability() []IStateMutabilityContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStateMutabilityContext)(nil)).Elem())
	var tst = make([]IStateMutabilityContext, len(ts))

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

	return tst
}

func (s *ModifierListContext) StateMutability(i int) IStateMutabilityContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStateMutabilityContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStateMutabilityContext)
}

func (s *ModifierListContext) AllExternalKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserExternalKeyword)
}

func (s *ModifierListContext) ExternalKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserExternalKeyword, i)
}

func (s *ModifierListContext) AllPublicKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserPublicKeyword)
}

func (s *ModifierListContext) PublicKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserPublicKeyword, i)
}

func (s *ModifierListContext) AllInternalKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserInternalKeyword)
}

func (s *ModifierListContext) InternalKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserInternalKeyword, i)
}

func (s *ModifierListContext) AllPrivateKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserPrivateKeyword)
}

func (s *ModifierListContext) PrivateKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserPrivateKeyword, i)
}

func (s *ModifierListContext) AllVirtualKeyword() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserVirtualKeyword)
}

func (s *ModifierListContext) VirtualKeyword(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserVirtualKeyword, i)
}

func (s *ModifierListContext) AllOverrideSpecifier() []IOverrideSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem())
	var tst = make([]IOverrideSpecifierContext, len(ts))

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

	return tst
}

func (s *ModifierListContext) OverrideSpecifier(i int) IOverrideSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOverrideSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOverrideSpecifierContext)
}

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

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

func (s *ModifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterModifierList(s)
	}
}

func (s *ModifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitModifierList(s)
	}
}

func (p *SolidityParser) ModifierList() (localctx IModifierListContext) {
	this := p
	_ = this

	localctx = NewModifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, SolidityParserRULE_modifierList)

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

	defer func() {
		if err := recover(); err != 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(402)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(400)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case SolidityParserT__12, SolidityParserT__39, SolidityParserT__51, SolidityParserIdentifier:
				{
					p.SetState(392)
					p.ModifierInvocation()
				}

			case SolidityParserConstantKeyword, SolidityParserPayableKeyword, SolidityParserPureKeyword, SolidityParserViewKeyword:
				{
					p.SetState(393)
					p.StateMutability()
				}

			case SolidityParserExternalKeyword:
				{
					p.SetState(394)
					p.Match(SolidityParserExternalKeyword)
				}

			case SolidityParserPublicKeyword:
				{
					p.SetState(395)
					p.Match(SolidityParserPublicKeyword)
				}

			case SolidityParserInternalKeyword:
				{
					p.SetState(396)
					p.Match(SolidityParserInternalKeyword)
				}

			case SolidityParserPrivateKeyword:
				{
					p.SetState(397)
					p.Match(SolidityParserPrivateKeyword)
				}

			case SolidityParserVirtualKeyword:
				{
					p.SetState(398)
					p.Match(SolidityParserVirtualKeyword)
				}

			case SolidityParserT__23:
				{
					p.SetState(399)
					p.OverrideSpecifier()
				}

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

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

	return localctx
}

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

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

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

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

func NewEmptyModifierInvocationContext() *ModifierInvocationContext {
	var p = new(ModifierInvocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_modifierInvocation
	return p
}

func (*ModifierInvocationContext) IsModifierInvocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_modifierInvocation

	return p
}

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

func (s *ModifierInvocationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *ModifierInvocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterModifierInvocation(s)
	}
}

func (s *ModifierInvocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitModifierInvocation(s)
	}
}

func (p *SolidityParser) ModifierInvocation() (localctx IModifierInvocationContext) {
	this := p
	_ = this

	localctx = NewModifierInvocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, SolidityParserRULE_modifierInvocation)
	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(405)
		p.Identifier()
	}
	p.SetState(411)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(406)
			p.Match(SolidityParserT__21)
		}
		p.SetState(408)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
			{
				p.SetState(407)
				p.ExpressionList()
			}

		}
		{
			p.SetState(410)
			p.Match(SolidityParserT__22)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEventDefinitionContext() *EventDefinitionContext {
	var p = new(EventDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_eventDefinition
	return p
}

func (*EventDefinitionContext) IsEventDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_eventDefinition

	return p
}

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

func (s *EventDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *EventDefinitionContext) EventParameterList() IEventParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEventParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEventParameterListContext)
}

func (s *EventDefinitionContext) AnonymousKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserAnonymousKeyword, 0)
}

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

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

func (s *EventDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEventDefinition(s)
	}
}

func (s *EventDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEventDefinition(s)
	}
}

func (p *SolidityParser) EventDefinition() (localctx IEventDefinitionContext) {
	this := p
	_ = this

	localctx = NewEventDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, SolidityParserRULE_eventDefinition)
	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(413)
		p.Match(SolidityParserT__30)
	}
	{
		p.SetState(414)
		p.Identifier()
	}
	{
		p.SetState(415)
		p.EventParameterList()
	}
	p.SetState(417)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserAnonymousKeyword {
		{
			p.SetState(416)
			p.Match(SolidityParserAnonymousKeyword)
		}

	}
	{
		p.SetState(419)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumDefinitionContext() *EnumDefinitionContext {
	var p = new(EnumDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_enumDefinition
	return p
}

func (*EnumDefinitionContext) IsEnumDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_enumDefinition

	return p
}

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

func (s *EnumDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *EnumDefinitionContext) AllEnumValue() []IEnumValueContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumValueContext)(nil)).Elem())
	var tst = make([]IEnumValueContext, len(ts))

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

	return tst
}

func (s *EnumDefinitionContext) EnumValue(i int) IEnumValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumValueContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumValueContext)
}

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

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

func (s *EnumDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEnumDefinition(s)
	}
}

func (s *EnumDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEnumDefinition(s)
	}
}

func (p *SolidityParser) EnumDefinition() (localctx IEnumDefinitionContext) {
	this := p
	_ = this

	localctx = NewEnumDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, SolidityParserRULE_enumDefinition)
	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(421)
		p.Match(SolidityParserT__31)
	}
	{
		p.SetState(422)
		p.Identifier()
	}
	{
		p.SetState(423)
		p.Match(SolidityParserT__13)
	}
	p.SetState(425)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		{
			p.SetState(424)
			p.EnumValue()
		}

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

	for _la == SolidityParserT__14 {
		{
			p.SetState(427)
			p.Match(SolidityParserT__14)
		}
		{
			p.SetState(428)
			p.EnumValue()
		}

		p.SetState(433)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(434)
		p.Match(SolidityParserT__15)
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumValueContext() *EnumValueContext {
	var p = new(EnumValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_enumValue
	return p
}

func (*EnumValueContext) IsEnumValueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_enumValue

	return p
}

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

func (s *EnumValueContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *EnumValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEnumValue(s)
	}
}

func (s *EnumValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEnumValue(s)
	}
}

func (p *SolidityParser) EnumValue() (localctx IEnumValueContext) {
	this := p
	_ = this

	localctx = NewEnumValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, SolidityParserRULE_enumValue)

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

	defer func() {
		if err := recover(); err != 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(436)
		p.Identifier()
	}

	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 = SolidityParserRULE_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 = SolidityParserRULE_parameterList

	return p
}

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

func (s *ParameterListContext) AllParameter() []IParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParameterContext)(nil)).Elem())
	var tst = make([]IParameterContext, len(ts))

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

	return tst
}

func (s *ParameterListContext) Parameter(i int) IParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IParameterContext)
}

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

func (s *ParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitParameterList(s)
	}
}

func (p *SolidityParser) ParameterList() (localctx IParameterListContext) {
	this := p
	_ = this

	localctx = NewParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, SolidityParserRULE_parameterList)
	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(438)
		p.Match(SolidityParserT__21)
	}
	p.SetState(447)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
		{
			p.SetState(439)
			p.Parameter()
		}
		p.SetState(444)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__14 {
			{
				p.SetState(440)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(441)
				p.Parameter()
			}

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

	}
	{
		p.SetState(449)
		p.Match(SolidityParserT__22)
	}

	return localctx
}

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

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

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

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

func NewEmptyParameterContext() *ParameterContext {
	var p = new(ParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_parameter
	return p
}

func (*ParameterContext) IsParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_parameter

	return p
}

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

func (s *ParameterContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *ParameterContext) StorageLocation() IStorageLocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStorageLocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStorageLocationContext)
}

func (s *ParameterContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterParameter(s)
	}
}

func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitParameter(s)
	}
}

func (p *SolidityParser) Parameter() (localctx IParameterContext) {
	this := p
	_ = this

	localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, SolidityParserRULE_parameter)
	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(451)
		p.typeName(0)
	}
	p.SetState(453)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(452)
			p.StorageLocation()
		}

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

	if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		{
			p.SetState(455)
			p.Identifier()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEventParameterListContext() *EventParameterListContext {
	var p = new(EventParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_eventParameterList
	return p
}

func (*EventParameterListContext) IsEventParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_eventParameterList

	return p
}

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

func (s *EventParameterListContext) AllEventParameter() []IEventParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEventParameterContext)(nil)).Elem())
	var tst = make([]IEventParameterContext, len(ts))

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

	return tst
}

func (s *EventParameterListContext) EventParameter(i int) IEventParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEventParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEventParameterContext)
}

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

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

func (s *EventParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEventParameterList(s)
	}
}

func (s *EventParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEventParameterList(s)
	}
}

func (p *SolidityParser) EventParameterList() (localctx IEventParameterListContext) {
	this := p
	_ = this

	localctx = NewEventParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, SolidityParserRULE_eventParameterList)
	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(458)
		p.Match(SolidityParserT__21)
	}
	p.SetState(467)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
		{
			p.SetState(459)
			p.EventParameter()
		}
		p.SetState(464)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SolidityParserT__14 {
			{
				p.SetState(460)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(461)
				p.EventParameter()
			}

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

	}
	{
		p.SetState(469)
		p.Match(SolidityParserT__22)
	}

	return localctx
}

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

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

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

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

func NewEmptyEventParameterContext() *EventParameterContext {
	var p = new(EventParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_eventParameter
	return p
}

func (*EventParameterContext) IsEventParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_eventParameter

	return p
}

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

func (s *EventParameterContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *EventParameterContext) IndexedKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserIndexedKeyword, 0)
}

func (s *EventParameterContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *EventParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEventParameter(s)
	}
}

func (s *EventParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEventParameter(s)
	}
}

func (p *SolidityParser) EventParameter() (localctx IEventParameterContext) {
	this := p
	_ = this

	localctx = NewEventParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, SolidityParserRULE_eventParameter)
	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(471)
		p.typeName(0)
	}
	p.SetState(473)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserIndexedKeyword {
		{
			p.SetState(472)
			p.Match(SolidityParserIndexedKeyword)
		}

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

	if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		{
			p.SetState(475)
			p.Identifier()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclarationContext() *VariableDeclarationContext {
	var p = new(VariableDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_variableDeclaration
	return p
}

func (*VariableDeclarationContext) IsVariableDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_variableDeclaration

	return p
}

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

func (s *VariableDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *VariableDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *VariableDeclarationContext) StorageLocation() IStorageLocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStorageLocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStorageLocationContext)
}

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

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

func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVariableDeclaration(s)
	}
}

func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVariableDeclaration(s)
	}
}

func (p *SolidityParser) VariableDeclaration() (localctx IVariableDeclarationContext) {
	this := p
	_ = this

	localctx = NewVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, SolidityParserRULE_variableDeclaration)

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

	defer func() {
		if err := recover(); err != 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(478)
		p.typeName(0)
	}
	p.SetState(480)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(479)
			p.StorageLocation()
		}

	}
	{
		p.SetState(482)
		p.Identifier()
	}

	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 = SolidityParserRULE_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 = SolidityParserRULE_typeName

	return p
}

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

func (s *TypeNameContext) ElementaryTypeName() IElementaryTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementaryTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementaryTypeNameContext)
}

func (s *TypeNameContext) UserDefinedTypeName() IUserDefinedTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserDefinedTypeNameContext)
}

func (s *TypeNameContext) Mapping() IMappingContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMappingContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMappingContext)
}

func (s *TypeNameContext) FunctionTypeName() IFunctionTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionTypeNameContext)
}

func (s *TypeNameContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

func (s *TypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitTypeName(s)
	}
}

func (p *SolidityParser) TypeName() (localctx ITypeNameContext) {
	return p.typeName(0)
}

func (p *SolidityParser) typeName(_p int) (localctx ITypeNameContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewTypeNameContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx ITypeNameContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 60
	p.EnterRecursionRule(localctx, 60, SolidityParserRULE_typeName, _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(489)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(485)
			p.ElementaryTypeName()
		}

	case 2:
		{
			p.SetState(486)
			p.UserDefinedTypeName()
		}

	case 3:
		{
			p.SetState(487)
			p.Mapping()
		}

	case 4:
		{
			p.SetState(488)
			p.FunctionTypeName()
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(499)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewTypeNameContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_typeName)
			p.SetState(491)

			if !(p.Precpred(p.GetParserRuleContext(), 2)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
			}
			{
				p.SetState(492)
				p.Match(SolidityParserT__32)
			}
			p.SetState(494)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
				{
					p.SetState(493)
					p.expression(0)
				}

			}
			{
				p.SetState(496)
				p.Match(SolidityParserT__33)
			}

		}
		p.SetState(501)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyUserDefinedTypeNameContext() *UserDefinedTypeNameContext {
	var p = new(UserDefinedTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_userDefinedTypeName
	return p
}

func (*UserDefinedTypeNameContext) IsUserDefinedTypeNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_userDefinedTypeName

	return p
}

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

func (s *UserDefinedTypeNameContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *UserDefinedTypeNameContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *UserDefinedTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterUserDefinedTypeName(s)
	}
}

func (s *UserDefinedTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitUserDefinedTypeName(s)
	}
}

func (p *SolidityParser) UserDefinedTypeName() (localctx IUserDefinedTypeNameContext) {
	this := p
	_ = this

	localctx = NewUserDefinedTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, SolidityParserRULE_userDefinedTypeName)

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

	defer func() {
		if err := recover(); err != 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(502)
		p.Identifier()
	}
	p.SetState(507)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(503)
				p.Match(SolidityParserT__34)
			}
			{
				p.SetState(504)
				p.Identifier()
			}

		}
		p.SetState(509)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyMappingContext() *MappingContext {
	var p = new(MappingContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_mapping
	return p
}

func (*MappingContext) IsMappingContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_mapping

	return p
}

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

func (s *MappingContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MappingContext) ElementaryTypeName() IElementaryTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementaryTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementaryTypeNameContext)
}

func (s *MappingContext) UserDefinedTypeName() IUserDefinedTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserDefinedTypeNameContext)
}

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

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

func (s *MappingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterMapping(s)
	}
}

func (s *MappingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitMapping(s)
	}
}

func (p *SolidityParser) Mapping() (localctx IMappingContext) {
	this := p
	_ = this

	localctx = NewMappingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, SolidityParserRULE_mapping)

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

	defer func() {
		if err := recover(); err != 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(510)
		p.Match(SolidityParserT__35)
	}
	{
		p.SetState(511)
		p.Match(SolidityParserT__21)
	}
	p.SetState(514)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 54, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(512)
			p.ElementaryTypeName()
		}

	case 2:
		{
			p.SetState(513)
			p.UserDefinedTypeName()
		}

	}
	{
		p.SetState(516)
		p.Match(SolidityParserT__36)
	}
	{
		p.SetState(517)
		p.typeName(0)
	}
	{
		p.SetState(518)
		p.Match(SolidityParserT__22)
	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionTypeNameContext() *FunctionTypeNameContext {
	var p = new(FunctionTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_functionTypeName
	return p
}

func (*FunctionTypeNameContext) IsFunctionTypeNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_functionTypeName

	return p
}

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

func (s *FunctionTypeNameContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *FunctionTypeNameContext) ModifierList() IModifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModifierListContext)
}

func (s *FunctionTypeNameContext) ReturnParameters() IReturnParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnParametersContext)
}

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

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

func (s *FunctionTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterFunctionTypeName(s)
	}
}

func (s *FunctionTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitFunctionTypeName(s)
	}
}

func (p *SolidityParser) FunctionTypeName() (localctx IFunctionTypeNameContext) {
	this := p
	_ = this

	localctx = NewFunctionTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, SolidityParserRULE_functionTypeName)

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

	defer func() {
		if err := recover(); err != 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(520)
		p.Match(SolidityParserT__28)
	}
	{
		p.SetState(521)
		p.ParameterList()
	}
	{
		p.SetState(522)
		p.ModifierList()
	}
	p.SetState(524)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(523)
			p.ReturnParameters()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyStorageLocationContext() *StorageLocationContext {
	var p = new(StorageLocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_storageLocation
	return p
}

func (*StorageLocationContext) IsStorageLocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_storageLocation

	return p
}

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

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

func (s *StorageLocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterStorageLocation(s)
	}
}

func (s *StorageLocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitStorageLocation(s)
	}
}

func (p *SolidityParser) StorageLocation() (localctx IStorageLocationContext) {
	this := p
	_ = this

	localctx = NewStorageLocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, SolidityParserRULE_storageLocation)
	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(526)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-38)&-(0x1f+1)) == 0 && ((1<<uint((_la-38)))&((1<<(SolidityParserT__37-38))|(1<<(SolidityParserT__38-38))|(1<<(SolidityParserT__39-38)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyStateMutabilityContext() *StateMutabilityContext {
	var p = new(StateMutabilityContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_stateMutability
	return p
}

func (*StateMutabilityContext) IsStateMutabilityContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_stateMutability

	return p
}

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

func (s *StateMutabilityContext) PureKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserPureKeyword, 0)
}

func (s *StateMutabilityContext) ConstantKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserConstantKeyword, 0)
}

func (s *StateMutabilityContext) ViewKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserViewKeyword, 0)
}

func (s *StateMutabilityContext) PayableKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserPayableKeyword, 0)
}

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

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

func (s *StateMutabilityContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterStateMutability(s)
	}
}

func (s *StateMutabilityContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitStateMutability(s)
	}
}

func (p *SolidityParser) StateMutability() (localctx IStateMutabilityContext) {
	this := p
	_ = this

	localctx = NewStateMutabilityContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, SolidityParserRULE_stateMutability)
	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(528)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-106)&-(0x1f+1)) == 0 && ((1<<uint((_la-106)))&((1<<(SolidityParserConstantKeyword-106))|(1<<(SolidityParserPayableKeyword-106))|(1<<(SolidityParserPureKeyword-106))|(1<<(SolidityParserViewKeyword-106)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = SolidityParserRULE_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 = SolidityParserRULE_block

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

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

	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, SolidityParserRULE_block)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(530)
		p.Match(SolidityParserT__13)
	}
	p.SetState(534)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__13)|(1<<SolidityParserT__21)|(1<<SolidityParserT__25)|(1<<SolidityParserT__28))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__35-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__40-33))|(1<<(SolidityParserT__42-33))|(1<<(SolidityParserT__44-33))|(1<<(SolidityParserT__45-33))|(1<<(SolidityParserT__46-33))|(1<<(SolidityParserT__47-33))|(1<<(SolidityParserT__48-33))|(1<<(SolidityParserT__49-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserBreakKeyword-93))|(1<<(SolidityParserContinueKeyword-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
		{
			p.SetState(531)
			p.Statement()
		}

		p.SetState(536)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(537)
		p.Match(SolidityParserT__15)
	}

	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 = SolidityParserRULE_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 = SolidityParserRULE_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IIfStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITryStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWhileStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IForStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IInlineAssemblyStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDoWhileStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IContinueStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBreakStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IReturnStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IThrowStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IEmitStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISimpleStatementContext)
}

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

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

func (p *SolidityParser) Statement() (localctx IStatementContext) {
	this := p
	_ = this

	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, SolidityParserRULE_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(552)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__40:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(539)
			p.IfStatement()
		}

	case SolidityParserT__42:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(540)
			p.TryStatement()
		}

	case SolidityParserT__44:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(541)
			p.WhileStatement()
		}

	case SolidityParserT__25:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(542)
			p.ForStatement()
		}

	case SolidityParserT__13:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(543)
			p.Block()
		}

	case SolidityParserT__45:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(544)
			p.InlineAssemblyStatement()
		}

	case SolidityParserT__46:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(545)
			p.DoWhileStatement()
		}

	case SolidityParserContinueKeyword:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(546)
			p.ContinueStatement()
		}

	case SolidityParserBreakKeyword:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(547)
			p.BreakStatement()
		}

	case SolidityParserT__47:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(548)
			p.ReturnStatement()
		}

	case SolidityParserT__48:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(549)
			p.ThrowStatement()
		}

	case SolidityParserT__49:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(550)
			p.EmitStatement()
		}

	case SolidityParserT__3, SolidityParserT__12, SolidityParserT__21, SolidityParserT__28, SolidityParserT__32, SolidityParserT__35, SolidityParserT__39, SolidityParserT__50, SolidityParserT__51, SolidityParserT__52, SolidityParserT__53, SolidityParserT__54, SolidityParserT__55, SolidityParserT__56, SolidityParserT__57, SolidityParserT__59, SolidityParserT__60, SolidityParserT__61, SolidityParserT__62, SolidityParserT__63, SolidityParserInt, SolidityParserUint, SolidityParserByte, SolidityParserFixed, SolidityParserUfixed, SolidityParserBooleanLiteral, SolidityParserDecimalNumber, SolidityParserHexNumber, SolidityParserHexLiteralFragment, SolidityParserPayableKeyword, SolidityParserTypeKeyword, SolidityParserIdentifier, SolidityParserStringLiteralFragment:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(551)
			p.SimpleStatement()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyExpressionStatementContext() *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_expressionStatement
	return p
}

func (*ExpressionStatementContext) IsExpressionStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_expressionStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterExpressionStatement(s)
	}
}

func (s *ExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitExpressionStatement(s)
	}
}

func (p *SolidityParser) ExpressionStatement() (localctx IExpressionStatementContext) {
	this := p
	_ = this

	localctx = NewExpressionStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, SolidityParserRULE_expressionStatement)

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

	defer func() {
		if err := recover(); err != 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(554)
		p.expression(0)
	}
	{
		p.SetState(555)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyIfStatementContext() *IfStatementContext {
	var p = new(IfStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_ifStatement
	return p
}

func (*IfStatementContext) IsIfStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_ifStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *IfStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterIfStatement(s)
	}
}

func (s *IfStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitIfStatement(s)
	}
}

func (p *SolidityParser) IfStatement() (localctx IIfStatementContext) {
	this := p
	_ = this

	localctx = NewIfStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, SolidityParserRULE_ifStatement)

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

	defer func() {
		if err := recover(); err != 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(557)
		p.Match(SolidityParserT__40)
	}
	{
		p.SetState(558)
		p.Match(SolidityParserT__21)
	}
	{
		p.SetState(559)
		p.expression(0)
	}
	{
		p.SetState(560)
		p.Match(SolidityParserT__22)
	}
	{
		p.SetState(561)
		p.Statement()
	}
	p.SetState(564)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 58, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(562)
			p.Match(SolidityParserT__41)
		}
		{
			p.SetState(563)
			p.Statement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTryStatementContext() *TryStatementContext {
	var p = new(TryStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_tryStatement
	return p
}

func (*TryStatementContext) IsTryStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_tryStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *TryStatementContext) ReturnParameters() IReturnParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnParametersContext)
}

func (s *TryStatementContext) AllCatchClause() []ICatchClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICatchClauseContext)(nil)).Elem())
	var tst = make([]ICatchClauseContext, len(ts))

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

	return tst
}

func (s *TryStatementContext) CatchClause(i int) ICatchClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICatchClauseContext)
}

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

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

func (s *TryStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterTryStatement(s)
	}
}

func (s *TryStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitTryStatement(s)
	}
}

func (p *SolidityParser) TryStatement() (localctx ITryStatementContext) {
	this := p
	_ = this

	localctx = NewTryStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, SolidityParserRULE_tryStatement)
	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(566)
		p.Match(SolidityParserT__42)
	}
	{
		p.SetState(567)
		p.expression(0)
	}
	p.SetState(569)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__29 {
		{
			p.SetState(568)
			p.ReturnParameters()
		}

	}
	{
		p.SetState(571)
		p.Block()
	}
	p.SetState(573)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == SolidityParserT__43 {
		{
			p.SetState(572)
			p.CatchClause()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCatchClauseContext() *CatchClauseContext {
	var p = new(CatchClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_catchClause
	return p
}

func (*CatchClauseContext) IsCatchClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_catchClause

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *CatchClauseContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *CatchClauseContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *CatchClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterCatchClause(s)
	}
}

func (s *CatchClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitCatchClause(s)
	}
}

func (p *SolidityParser) CatchClause() (localctx ICatchClauseContext) {
	this := p
	_ = this

	localctx = NewCatchClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, SolidityParserRULE_catchClause)
	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(577)
		p.Match(SolidityParserT__43)
	}
	p.SetState(582)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__21 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		p.SetState(579)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
			{
				p.SetState(578)
				p.Identifier()
			}

		}
		{
			p.SetState(581)
			p.ParameterList()
		}

	}
	{
		p.SetState(584)
		p.Block()
	}

	return localctx
}

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

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

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

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

func NewEmptyWhileStatementContext() *WhileStatementContext {
	var p = new(WhileStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_whileStatement
	return p
}

func (*WhileStatementContext) IsWhileStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_whileStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterWhileStatement(s)
	}
}

func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitWhileStatement(s)
	}
}

func (p *SolidityParser) WhileStatement() (localctx IWhileStatementContext) {
	this := p
	_ = this

	localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, SolidityParserRULE_whileStatement)

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

	defer func() {
		if err := recover(); err != 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(586)
		p.Match(SolidityParserT__44)
	}
	{
		p.SetState(587)
		p.Match(SolidityParserT__21)
	}
	{
		p.SetState(588)
		p.expression(0)
	}
	{
		p.SetState(589)
		p.Match(SolidityParserT__22)
	}
	{
		p.SetState(590)
		p.Statement()
	}

	return localctx
}

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

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

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

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

func NewEmptyForStatementContext() *ForStatementContext {
	var p = new(ForStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_forStatement
	return p
}

func (*ForStatementContext) IsForStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_forStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ForStatementContext) SimpleStatement() ISimpleStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleStatementContext)
}

func (s *ForStatementContext) ExpressionStatement() IExpressionStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ForStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterForStatement(s)
	}
}

func (s *ForStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitForStatement(s)
	}
}

func (p *SolidityParser) ForStatement() (localctx IForStatementContext) {
	this := p
	_ = this

	localctx = NewForStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, SolidityParserRULE_forStatement)
	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(592)
		p.Match(SolidityParserT__25)
	}
	{
		p.SetState(593)
		p.Match(SolidityParserT__21)
	}
	p.SetState(596)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__3, SolidityParserT__12, SolidityParserT__21, SolidityParserT__28, SolidityParserT__32, SolidityParserT__35, SolidityParserT__39, SolidityParserT__50, SolidityParserT__51, SolidityParserT__52, SolidityParserT__53, SolidityParserT__54, SolidityParserT__55, SolidityParserT__56, SolidityParserT__57, SolidityParserT__59, SolidityParserT__60, SolidityParserT__61, SolidityParserT__62, SolidityParserT__63, SolidityParserInt, SolidityParserUint, SolidityParserByte, SolidityParserFixed, SolidityParserUfixed, SolidityParserBooleanLiteral, SolidityParserDecimalNumber, SolidityParserHexNumber, SolidityParserHexLiteralFragment, SolidityParserPayableKeyword, SolidityParserTypeKeyword, SolidityParserIdentifier, SolidityParserStringLiteralFragment:
		{
			p.SetState(594)
			p.SimpleStatement()
		}

	case SolidityParserT__1:
		{
			p.SetState(595)
			p.Match(SolidityParserT__1)
		}

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

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__3, SolidityParserT__12, SolidityParserT__21, SolidityParserT__32, SolidityParserT__39, SolidityParserT__50, SolidityParserT__51, SolidityParserT__52, SolidityParserT__53, SolidityParserT__54, SolidityParserT__55, SolidityParserT__56, SolidityParserT__57, SolidityParserT__59, SolidityParserT__60, SolidityParserT__61, SolidityParserT__62, SolidityParserT__63, SolidityParserInt, SolidityParserUint, SolidityParserByte, SolidityParserFixed, SolidityParserUfixed, SolidityParserBooleanLiteral, SolidityParserDecimalNumber, SolidityParserHexNumber, SolidityParserHexLiteralFragment, SolidityParserPayableKeyword, SolidityParserTypeKeyword, SolidityParserIdentifier, SolidityParserStringLiteralFragment:
		{
			p.SetState(598)
			p.ExpressionStatement()
		}

	case SolidityParserT__1:
		{
			p.SetState(599)
			p.Match(SolidityParserT__1)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(603)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
		{
			p.SetState(602)
			p.expression(0)
		}

	}
	{
		p.SetState(605)
		p.Match(SolidityParserT__22)
	}
	{
		p.SetState(606)
		p.Statement()
	}

	return localctx
}

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

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

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

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

func NewEmptySimpleStatementContext() *SimpleStatementContext {
	var p = new(SimpleStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_simpleStatement
	return p
}

func (*SimpleStatementContext) IsSimpleStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_simpleStatement

	return p
}

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

func (s *SimpleStatementContext) VariableDeclarationStatement() IVariableDeclarationStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationStatementContext)
}

func (s *SimpleStatementContext) ExpressionStatement() IExpressionStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionStatementContext)
}

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

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

func (s *SimpleStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterSimpleStatement(s)
	}
}

func (s *SimpleStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitSimpleStatement(s)
	}
}

func (p *SolidityParser) SimpleStatement() (localctx ISimpleStatementContext) {
	this := p
	_ = this

	localctx = NewSimpleStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, SolidityParserRULE_simpleStatement)

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

	defer func() {
		if err := recover(); err != 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(610)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(608)
			p.VariableDeclarationStatement()
		}

	case 2:
		{
			p.SetState(609)
			p.ExpressionStatement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInlineAssemblyStatementContext() *InlineAssemblyStatementContext {
	var p = new(InlineAssemblyStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_inlineAssemblyStatement
	return p
}

func (*InlineAssemblyStatementContext) IsInlineAssemblyStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_inlineAssemblyStatement

	return p
}

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

func (s *InlineAssemblyStatementContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *InlineAssemblyStatementContext) StringLiteralFragment() antlr.TerminalNode {
	return s.GetToken(SolidityParserStringLiteralFragment, 0)
}

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

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

func (s *InlineAssemblyStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterInlineAssemblyStatement(s)
	}
}

func (s *InlineAssemblyStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitInlineAssemblyStatement(s)
	}
}

func (p *SolidityParser) InlineAssemblyStatement() (localctx IInlineAssemblyStatementContext) {
	this := p
	_ = this

	localctx = NewInlineAssemblyStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, SolidityParserRULE_inlineAssemblyStatement)
	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(612)
		p.Match(SolidityParserT__45)
	}
	p.SetState(614)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserStringLiteralFragment {
		{
			p.SetState(613)
			p.Match(SolidityParserStringLiteralFragment)
		}

	}
	{
		p.SetState(616)
		p.AssemblyBlock()
	}

	return localctx
}

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

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

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

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

func NewEmptyDoWhileStatementContext() *DoWhileStatementContext {
	var p = new(DoWhileStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_doWhileStatement
	return p
}

func (*DoWhileStatementContext) IsDoWhileStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_doWhileStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *DoWhileStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterDoWhileStatement(s)
	}
}

func (s *DoWhileStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitDoWhileStatement(s)
	}
}

func (p *SolidityParser) DoWhileStatement() (localctx IDoWhileStatementContext) {
	this := p
	_ = this

	localctx = NewDoWhileStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, SolidityParserRULE_doWhileStatement)

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

	defer func() {
		if err := recover(); err != 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(618)
		p.Match(SolidityParserT__46)
	}
	{
		p.SetState(619)
		p.Statement()
	}
	{
		p.SetState(620)
		p.Match(SolidityParserT__44)
	}
	{
		p.SetState(621)
		p.Match(SolidityParserT__21)
	}
	{
		p.SetState(622)
		p.expression(0)
	}
	{
		p.SetState(623)
		p.Match(SolidityParserT__22)
	}
	{
		p.SetState(624)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyContinueStatementContext() *ContinueStatementContext {
	var p = new(ContinueStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_continueStatement
	return p
}

func (*ContinueStatementContext) IsContinueStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_continueStatement

	return p
}

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

func (s *ContinueStatementContext) ContinueKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserContinueKeyword, 0)
}

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

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

func (s *ContinueStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterContinueStatement(s)
	}
}

func (s *ContinueStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitContinueStatement(s)
	}
}

func (p *SolidityParser) ContinueStatement() (localctx IContinueStatementContext) {
	this := p
	_ = this

	localctx = NewContinueStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, SolidityParserRULE_continueStatement)

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

	defer func() {
		if err := recover(); err != 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(626)
		p.Match(SolidityParserContinueKeyword)
	}
	{
		p.SetState(627)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyBreakStatementContext() *BreakStatementContext {
	var p = new(BreakStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_breakStatement
	return p
}

func (*BreakStatementContext) IsBreakStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_breakStatement

	return p
}

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

func (s *BreakStatementContext) BreakKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserBreakKeyword, 0)
}

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

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

func (s *BreakStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterBreakStatement(s)
	}
}

func (s *BreakStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitBreakStatement(s)
	}
}

func (p *SolidityParser) BreakStatement() (localctx IBreakStatementContext) {
	this := p
	_ = this

	localctx = NewBreakStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, SolidityParserRULE_breakStatement)

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

	defer func() {
		if err := recover(); err != 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(629)
		p.Match(SolidityParserBreakKeyword)
	}
	{
		p.SetState(630)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyReturnStatementContext() *ReturnStatementContext {
	var p = new(ReturnStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_returnStatement
	return p
}

func (*ReturnStatementContext) IsReturnStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_returnStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ReturnStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterReturnStatement(s)
	}
}

func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitReturnStatement(s)
	}
}

func (p *SolidityParser) ReturnStatement() (localctx IReturnStatementContext) {
	this := p
	_ = this

	localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, SolidityParserRULE_returnStatement)
	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(632)
		p.Match(SolidityParserT__47)
	}
	p.SetState(634)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
		{
			p.SetState(633)
			p.expression(0)
		}

	}
	{
		p.SetState(636)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyThrowStatementContext() *ThrowStatementContext {
	var p = new(ThrowStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_throwStatement
	return p
}

func (*ThrowStatementContext) IsThrowStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_throwStatement

	return p
}

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

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

func (s *ThrowStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterThrowStatement(s)
	}
}

func (s *ThrowStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitThrowStatement(s)
	}
}

func (p *SolidityParser) ThrowStatement() (localctx IThrowStatementContext) {
	this := p
	_ = this

	localctx = NewThrowStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, SolidityParserRULE_throwStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(638)
		p.Match(SolidityParserT__48)
	}
	{
		p.SetState(639)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyEmitStatementContext() *EmitStatementContext {
	var p = new(EmitStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_emitStatement
	return p
}

func (*EmitStatementContext) IsEmitStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_emitStatement

	return p
}

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

func (s *EmitStatementContext) FunctionCall() IFunctionCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallContext)
}

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

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

func (s *EmitStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterEmitStatement(s)
	}
}

func (s *EmitStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitEmitStatement(s)
	}
}

func (p *SolidityParser) EmitStatement() (localctx IEmitStatementContext) {
	this := p
	_ = this

	localctx = NewEmitStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, SolidityParserRULE_emitStatement)

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

	defer func() {
		if err := recover(); err != 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(641)
		p.Match(SolidityParserT__49)
	}
	{
		p.SetState(642)
		p.FunctionCall()
	}
	{
		p.SetState(643)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclarationStatementContext() *VariableDeclarationStatementContext {
	var p = new(VariableDeclarationStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_variableDeclarationStatement
	return p
}

func (*VariableDeclarationStatementContext) IsVariableDeclarationStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_variableDeclarationStatement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

func (s *VariableDeclarationStatementContext) VariableDeclaration() IVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationContext)
}

func (s *VariableDeclarationStatementContext) VariableDeclarationList() IVariableDeclarationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationListContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *VariableDeclarationStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVariableDeclarationStatement(s)
	}
}

func (s *VariableDeclarationStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVariableDeclarationStatement(s)
	}
}

func (p *SolidityParser) VariableDeclarationStatement() (localctx IVariableDeclarationStatementContext) {
	this := p
	_ = this

	localctx = NewVariableDeclarationStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, SolidityParserRULE_variableDeclarationStatement)
	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(652)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(645)
			p.Match(SolidityParserT__50)
		}
		{
			p.SetState(646)
			p.IdentifierList()
		}

	case 2:
		{
			p.SetState(647)
			p.VariableDeclaration()
		}

	case 3:
		{
			p.SetState(648)
			p.Match(SolidityParserT__21)
		}
		{
			p.SetState(649)
			p.VariableDeclarationList()
		}
		{
			p.SetState(650)
			p.Match(SolidityParserT__22)
		}

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

	if _la == SolidityParserT__8 {
		{
			p.SetState(654)
			p.Match(SolidityParserT__8)
		}
		{
			p.SetState(655)
			p.expression(0)
		}

	}
	{
		p.SetState(658)
		p.Match(SolidityParserT__1)
	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclarationListContext() *VariableDeclarationListContext {
	var p = new(VariableDeclarationListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_variableDeclarationList
	return p
}

func (*VariableDeclarationListContext) IsVariableDeclarationListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_variableDeclarationList

	return p
}

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

func (s *VariableDeclarationListContext) AllVariableDeclaration() []IVariableDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem())
	var tst = make([]IVariableDeclarationContext, len(ts))

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

	return tst
}

func (s *VariableDeclarationListContext) VariableDeclaration(i int) IVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationContext)
}

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

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

func (s *VariableDeclarationListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterVariableDeclarationList(s)
	}
}

func (s *VariableDeclarationListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitVariableDeclarationList(s)
	}
}

func (p *SolidityParser) VariableDeclarationList() (localctx IVariableDeclarationListContext) {
	this := p
	_ = this

	localctx = NewVariableDeclarationListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, SolidityParserRULE_variableDeclarationList)
	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(661)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
		{
			p.SetState(660)
			p.VariableDeclaration()
		}

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

	for _la == SolidityParserT__14 {
		{
			p.SetState(663)
			p.Match(SolidityParserT__14)
		}
		p.SetState(665)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__12 || _la == SolidityParserT__28 || (((_la-36)&-(0x1f+1)) == 0 && ((1<<uint((_la-36)))&((1<<(SolidityParserT__35-36))|(1<<(SolidityParserT__39-36))|(1<<(SolidityParserT__50-36))|(1<<(SolidityParserT__51-36))|(1<<(SolidityParserT__52-36))|(1<<(SolidityParserT__53-36))|(1<<(SolidityParserT__54-36)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserIdentifier-93)))) != 0) {
			{
				p.SetState(664)
				p.VariableDeclaration()
			}

		}

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

	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 = SolidityParserRULE_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 = SolidityParserRULE_identifierList

	return p
}

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

func (s *IdentifierListContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *IdentifierListContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (p *SolidityParser) IdentifierList() (localctx IIdentifierListContext) {
	this := p
	_ = this

	localctx = NewIdentifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, SolidityParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(672)
		p.Match(SolidityParserT__21)
	}
	p.SetState(679)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext())

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

			if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
				{
					p.SetState(673)
					p.Identifier()
				}

			}
			{
				p.SetState(676)
				p.Match(SolidityParserT__14)
			}

		}
		p.SetState(681)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext())
	}
	p.SetState(683)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		{
			p.SetState(682)
			p.Identifier()
		}

	}
	{
		p.SetState(685)
		p.Match(SolidityParserT__22)
	}

	return localctx
}

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

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

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

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

func NewEmptyElementaryTypeNameContext() *ElementaryTypeNameContext {
	var p = new(ElementaryTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_elementaryTypeName
	return p
}

func (*ElementaryTypeNameContext) IsElementaryTypeNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_elementaryTypeName

	return p
}

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

func (s *ElementaryTypeNameContext) PayableKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserPayableKeyword, 0)
}

func (s *ElementaryTypeNameContext) Int() antlr.TerminalNode {
	return s.GetToken(SolidityParserInt, 0)
}

func (s *ElementaryTypeNameContext) Uint() antlr.TerminalNode {
	return s.GetToken(SolidityParserUint, 0)
}

func (s *ElementaryTypeNameContext) Byte() antlr.TerminalNode {
	return s.GetToken(SolidityParserByte, 0)
}

func (s *ElementaryTypeNameContext) Fixed() antlr.TerminalNode {
	return s.GetToken(SolidityParserFixed, 0)
}

func (s *ElementaryTypeNameContext) Ufixed() antlr.TerminalNode {
	return s.GetToken(SolidityParserUfixed, 0)
}

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

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

func (s *ElementaryTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterElementaryTypeName(s)
	}
}

func (s *ElementaryTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitElementaryTypeName(s)
	}
}

func (p *SolidityParser) ElementaryTypeName() (localctx IElementaryTypeNameContext) {
	this := p
	_ = this

	localctx = NewElementaryTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, SolidityParserRULE_elementaryTypeName)

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

	defer func() {
		if err := recover(); err != 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(700)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__51:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(687)
			p.Match(SolidityParserT__51)
		}
		p.SetState(689)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(688)
				p.Match(SolidityParserPayableKeyword)
			}

		}

	case SolidityParserT__52:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(691)
			p.Match(SolidityParserT__52)
		}

	case SolidityParserT__53:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(692)
			p.Match(SolidityParserT__53)
		}

	case SolidityParserT__50:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(693)
			p.Match(SolidityParserT__50)
		}

	case SolidityParserInt:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(694)
			p.Match(SolidityParserInt)
		}

	case SolidityParserUint:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(695)
			p.Match(SolidityParserUint)
		}

	case SolidityParserT__54:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(696)
			p.Match(SolidityParserT__54)
		}

	case SolidityParserByte:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(697)
			p.Match(SolidityParserByte)
		}

	case SolidityParserFixed:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(698)
			p.Match(SolidityParserFixed)
		}

	case SolidityParserUfixed:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(699)
			p.Match(SolidityParserUfixed)
		}

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

	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 = SolidityParserRULE_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 = SolidityParserRULE_expression

	return p
}

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

func (s *ExpressionContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *ExpressionContext) PayableKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserPayableKeyword, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IPrimaryExpressionContext)
}

func (s *ExpressionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *ExpressionContext) NameValueList() INameValueListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameValueListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameValueListContext)
}

func (s *ExpressionContext) FunctionCallArguments() IFunctionCallArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallArgumentsContext)
}

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

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *SolidityParser) Expression() (localctx IExpressionContext) {
	return p.expression(0)
}

func (p *SolidityParser) expression(_p int) (localctx IExpressionContext) {
	this := p
	_ = this

	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 := 112
	p.EnterRecursionRule(localctx, 112, SolidityParserRULE_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(725)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(703)
			p.Match(SolidityParserT__57)
		}
		{
			p.SetState(704)
			p.typeName(0)
		}

	case 2:
		{
			p.SetState(705)
			p.Match(SolidityParserPayableKeyword)
		}
		{
			p.SetState(706)
			p.Match(SolidityParserT__21)
		}
		{
			p.SetState(707)
			p.expression(0)
		}
		{
			p.SetState(708)
			p.Match(SolidityParserT__22)
		}

	case 3:
		{
			p.SetState(710)
			p.Match(SolidityParserT__21)
		}
		{
			p.SetState(711)
			p.expression(0)
		}
		{
			p.SetState(712)
			p.Match(SolidityParserT__22)
		}

	case 4:
		{
			p.SetState(714)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SolidityParserT__55 || _la == SolidityParserT__56) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(715)
			p.expression(19)
		}

	case 5:
		{
			p.SetState(716)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SolidityParserT__59 || _la == SolidityParserT__60) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(717)
			p.expression(18)
		}

	case 6:
		{
			p.SetState(718)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SolidityParserT__61 || _la == SolidityParserT__62) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(719)
			p.expression(17)
		}

	case 7:
		{
			p.SetState(720)
			p.Match(SolidityParserT__63)
		}
		{
			p.SetState(721)
			p.expression(16)
		}

	case 8:
		{
			p.SetState(722)
			p.Match(SolidityParserT__3)
		}
		{
			p.SetState(723)
			p.expression(15)
		}

	case 9:
		{
			p.SetState(724)
			p.PrimaryExpression()
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(802)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(800)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(727)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(728)
					p.Match(SolidityParserT__64)
				}
				{
					p.SetState(729)
					p.expression(15)
				}

			case 2:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(730)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(731)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SolidityParserT__11 || _la == SolidityParserT__65 || _la == SolidityParserT__66) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(732)
					p.expression(14)
				}

			case 3:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(733)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(734)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SolidityParserT__59 || _la == SolidityParserT__60) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(735)
					p.expression(13)
				}

			case 4:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(736)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				{
					p.SetState(737)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SolidityParserT__67 || _la == SolidityParserT__68) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(738)
					p.expression(12)
				}

			case 5:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(739)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				{
					p.SetState(740)
					p.Match(SolidityParserT__69)
				}
				{
					p.SetState(741)
					p.expression(11)
				}

			case 6:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(742)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(743)
					p.Match(SolidityParserT__2)
				}
				{
					p.SetState(744)
					p.expression(10)
				}

			case 7:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(745)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(746)
					p.Match(SolidityParserT__70)
				}
				{
					p.SetState(747)
					p.expression(9)
				}

			case 8:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(748)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				{
					p.SetState(749)
					_la = p.GetTokenStream().LA(1)

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__4)|(1<<SolidityParserT__5)|(1<<SolidityParserT__6)|(1<<SolidityParserT__7))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(750)
					p.expression(8)
				}

			case 9:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(751)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(752)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SolidityParserT__71 || _la == SolidityParserT__72) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(753)
					p.expression(7)
				}

			case 10:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(754)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(755)
					p.Match(SolidityParserT__73)
				}
				{
					p.SetState(756)
					p.expression(6)
				}

			case 11:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(757)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				{
					p.SetState(758)
					p.Match(SolidityParserT__74)
				}
				{
					p.SetState(759)
					p.expression(5)
				}

			case 12:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(760)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(761)
					p.Match(SolidityParserT__75)
				}
				{
					p.SetState(762)
					p.expression(0)
				}
				{
					p.SetState(763)
					p.Match(SolidityParserT__58)
				}
				{
					p.SetState(764)
					p.expression(4)
				}

			case 13:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(766)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(767)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SolidityParserT__8 || (((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(SolidityParserT__76-77))|(1<<(SolidityParserT__77-77))|(1<<(SolidityParserT__78-77))|(1<<(SolidityParserT__79-77))|(1<<(SolidityParserT__80-77))|(1<<(SolidityParserT__81-77))|(1<<(SolidityParserT__82-77))|(1<<(SolidityParserT__83-77))|(1<<(SolidityParserT__84-77))|(1<<(SolidityParserT__85-77)))) != 0)) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(768)
					p.expression(3)
				}

			case 14:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(769)

				if !(p.Precpred(p.GetParserRuleContext(), 28)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 28)", ""))
				}
				{
					p.SetState(770)
					_la = p.GetTokenStream().LA(1)

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

			case 15:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(771)

				if !(p.Precpred(p.GetParserRuleContext(), 26)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
				}
				{
					p.SetState(772)
					p.Match(SolidityParserT__32)
				}
				p.SetState(774)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
					{
						p.SetState(773)
						p.expression(0)
					}

				}
				{
					p.SetState(776)
					p.Match(SolidityParserT__33)
				}

			case 16:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(777)

				if !(p.Precpred(p.GetParserRuleContext(), 25)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
				}
				{
					p.SetState(778)
					p.Match(SolidityParserT__32)
				}
				p.SetState(780)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
					{
						p.SetState(779)
						p.expression(0)
					}

				}
				{
					p.SetState(782)
					p.Match(SolidityParserT__58)
				}
				p.SetState(784)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
					{
						p.SetState(783)
						p.expression(0)
					}

				}
				{
					p.SetState(786)
					p.Match(SolidityParserT__33)
				}

			case 17:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(787)

				if !(p.Precpred(p.GetParserRuleContext(), 24)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", ""))
				}
				{
					p.SetState(788)
					p.Match(SolidityParserT__34)
				}
				{
					p.SetState(789)
					p.Identifier()
				}

			case 18:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(790)

				if !(p.Precpred(p.GetParserRuleContext(), 23)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 23)", ""))
				}
				{
					p.SetState(791)
					p.Match(SolidityParserT__13)
				}
				{
					p.SetState(792)
					p.NameValueList()
				}
				{
					p.SetState(793)
					p.Match(SolidityParserT__15)
				}

			case 19:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SolidityParserRULE_expression)
				p.SetState(795)

				if !(p.Precpred(p.GetParserRuleContext(), 22)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", ""))
				}
				{
					p.SetState(796)
					p.Match(SolidityParserT__21)
				}
				{
					p.SetState(797)
					p.FunctionCallArguments()
				}
				{
					p.SetState(798)
					p.Match(SolidityParserT__22)
				}

			}

		}
		p.SetState(804)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext {
	var p = new(PrimaryExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_primaryExpression
	return p
}

func (*PrimaryExpressionContext) IsPrimaryExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_primaryExpression

	return p
}

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

func (s *PrimaryExpressionContext) BooleanLiteral() antlr.TerminalNode {
	return s.GetToken(SolidityParserBooleanLiteral, 0)
}

func (s *PrimaryExpressionContext) NumberLiteral() INumberLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumberLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumberLiteralContext)
}

func (s *PrimaryExpressionContext) HexLiteral() IHexLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IHexLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IHexLiteralContext)
}

func (s *PrimaryExpressionContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *PrimaryExpressionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *PrimaryExpressionContext) TypeKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserTypeKeyword, 0)
}

func (s *PrimaryExpressionContext) TupleExpression() ITupleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITupleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITupleExpressionContext)
}

func (s *PrimaryExpressionContext) TypeNameExpression() ITypeNameExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameExpressionContext)
}

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

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

func (s *PrimaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterPrimaryExpression(s)
	}
}

func (s *PrimaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitPrimaryExpression(s)
	}
}

func (p *SolidityParser) PrimaryExpression() (localctx IPrimaryExpressionContext) {
	this := p
	_ = this

	localctx = NewPrimaryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, SolidityParserRULE_primaryExpression)

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

	defer func() {
		if err := recover(); err != 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(821)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(805)
			p.Match(SolidityParserBooleanLiteral)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(806)
			p.NumberLiteral()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(807)
			p.HexLiteral()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(808)
			p.StringLiteral()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(809)
			p.Identifier()
		}
		p.SetState(812)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(810)
				p.Match(SolidityParserT__32)
			}
			{
				p.SetState(811)
				p.Match(SolidityParserT__33)
			}

		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(814)
			p.Match(SolidityParserTypeKeyword)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(815)
			p.TupleExpression()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(816)
			p.TypeNameExpression()
		}
		p.SetState(819)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(817)
				p.Match(SolidityParserT__32)
			}
			{
				p.SetState(818)
				p.Match(SolidityParserT__33)
			}

		}

	}

	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 = SolidityParserRULE_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 = SolidityParserRULE_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.(SolidityListener); ok {
		listenerT.EnterExpressionList(s)
	}
}

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

func (p *SolidityParser) ExpressionList() (localctx IExpressionListContext) {
	this := p
	_ = this

	localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, SolidityParserRULE_expressionList)
	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(823)
		p.expression(0)
	}
	p.SetState(828)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SolidityParserT__14 {
		{
			p.SetState(824)
			p.Match(SolidityParserT__14)
		}
		{
			p.SetState(825)
			p.expression(0)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyNameValueListContext() *NameValueListContext {
	var p = new(NameValueListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_nameValueList
	return p
}

func (*NameValueListContext) IsNameValueListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_nameValueList

	return p
}

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

func (s *NameValueListContext) AllNameValue() []INameValueContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*INameValueContext)(nil)).Elem())
	var tst = make([]INameValueContext, len(ts))

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

	return tst
}

func (s *NameValueListContext) NameValue(i int) INameValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameValueContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INameValueContext)
}

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

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

func (s *NameValueListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterNameValueList(s)
	}
}

func (s *NameValueListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitNameValueList(s)
	}
}

func (p *SolidityParser) NameValueList() (localctx INameValueListContext) {
	this := p
	_ = this

	localctx = NewNameValueListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, SolidityParserRULE_nameValueList)
	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(831)
		p.NameValue()
	}
	p.SetState(836)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(832)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(833)
				p.NameValue()
			}

		}
		p.SetState(838)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext())
	}
	p.SetState(840)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__14 {
		{
			p.SetState(839)
			p.Match(SolidityParserT__14)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNameValueContext() *NameValueContext {
	var p = new(NameValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_nameValue
	return p
}

func (*NameValueContext) IsNameValueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_nameValue

	return p
}

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

func (s *NameValueContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *NameValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterNameValue(s)
	}
}

func (s *NameValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitNameValue(s)
	}
}

func (p *SolidityParser) NameValue() (localctx INameValueContext) {
	this := p
	_ = this

	localctx = NewNameValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, SolidityParserRULE_nameValue)

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

	defer func() {
		if err := recover(); err != 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(842)
		p.Identifier()
	}
	{
		p.SetState(843)
		p.Match(SolidityParserT__58)
	}
	{
		p.SetState(844)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionCallArgumentsContext() *FunctionCallArgumentsContext {
	var p = new(FunctionCallArgumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_functionCallArguments
	return p
}

func (*FunctionCallArgumentsContext) IsFunctionCallArgumentsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_functionCallArguments

	return p
}

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

func (s *FunctionCallArgumentsContext) NameValueList() INameValueListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameValueListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameValueListContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *FunctionCallArgumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterFunctionCallArguments(s)
	}
}

func (s *FunctionCallArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitFunctionCallArguments(s)
	}
}

func (p *SolidityParser) FunctionCallArguments() (localctx IFunctionCallArgumentsContext) {
	this := p
	_ = this

	localctx = NewFunctionCallArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, SolidityParserRULE_functionCallArguments)
	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(854)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__13:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(846)
			p.Match(SolidityParserT__13)
		}
		p.SetState(848)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
			{
				p.SetState(847)
				p.NameValueList()
			}

		}
		{
			p.SetState(850)
			p.Match(SolidityParserT__15)
		}

	case SolidityParserT__3, SolidityParserT__12, SolidityParserT__21, SolidityParserT__22, SolidityParserT__32, SolidityParserT__39, SolidityParserT__50, SolidityParserT__51, SolidityParserT__52, SolidityParserT__53, SolidityParserT__54, SolidityParserT__55, SolidityParserT__56, SolidityParserT__57, SolidityParserT__59, SolidityParserT__60, SolidityParserT__61, SolidityParserT__62, SolidityParserT__63, SolidityParserInt, SolidityParserUint, SolidityParserByte, SolidityParserFixed, SolidityParserUfixed, SolidityParserBooleanLiteral, SolidityParserDecimalNumber, SolidityParserHexNumber, SolidityParserHexLiteralFragment, SolidityParserPayableKeyword, SolidityParserTypeKeyword, SolidityParserIdentifier, SolidityParserStringLiteralFragment:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(852)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
			{
				p.SetState(851)
				p.ExpressionList()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyFunctionCallContext() *FunctionCallContext {
	var p = new(FunctionCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_functionCall
	return p
}

func (*FunctionCallContext) IsFunctionCallContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_functionCall

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *FunctionCallContext) FunctionCallArguments() IFunctionCallArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallArgumentsContext)
}

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

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

func (s *FunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterFunctionCall(s)
	}
}

func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitFunctionCall(s)
	}
}

func (p *SolidityParser) FunctionCall() (localctx IFunctionCallContext) {
	this := p
	_ = this

	localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, SolidityParserRULE_functionCall)

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

	defer func() {
		if err := recover(); err != 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(856)
		p.expression(0)
	}
	{
		p.SetState(857)
		p.Match(SolidityParserT__21)
	}
	{
		p.SetState(858)
		p.FunctionCallArguments()
	}
	{
		p.SetState(859)
		p.Match(SolidityParserT__22)
	}

	return localctx
}

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

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

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

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

func NewEmptyTupleExpressionContext() *TupleExpressionContext {
	var p = new(TupleExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_tupleExpression
	return p
}

func (*TupleExpressionContext) IsTupleExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_tupleExpression

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *TupleExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterTupleExpression(s)
	}
}

func (s *TupleExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitTupleExpression(s)
	}
}

func (p *SolidityParser) TupleExpression() (localctx ITupleExpressionContext) {
	this := p
	_ = this

	localctx = NewTupleExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, SolidityParserRULE_tupleExpression)
	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(887)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__21:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(861)
			p.Match(SolidityParserT__21)
		}

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

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
			{
				p.SetState(862)
				p.expression(0)
			}

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

		for _la == SolidityParserT__14 {
			{
				p.SetState(865)
				p.Match(SolidityParserT__14)
			}
			p.SetState(867)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
				{
					p.SetState(866)
					p.expression(0)
				}

			}

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

		{
			p.SetState(874)
			p.Match(SolidityParserT__22)
		}

	case SolidityParserT__32:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(875)
			p.Match(SolidityParserT__32)
		}
		p.SetState(884)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__3)|(1<<SolidityParserT__12)|(1<<SolidityParserT__21))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(SolidityParserT__32-33))|(1<<(SolidityParserT__39-33))|(1<<(SolidityParserT__50-33))|(1<<(SolidityParserT__51-33))|(1<<(SolidityParserT__52-33))|(1<<(SolidityParserT__53-33))|(1<<(SolidityParserT__54-33))|(1<<(SolidityParserT__55-33))|(1<<(SolidityParserT__56-33))|(1<<(SolidityParserT__57-33))|(1<<(SolidityParserT__59-33))|(1<<(SolidityParserT__60-33))|(1<<(SolidityParserT__61-33))|(1<<(SolidityParserT__62-33))|(1<<(SolidityParserT__63-33)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(SolidityParserInt-93))|(1<<(SolidityParserUint-93))|(1<<(SolidityParserByte-93))|(1<<(SolidityParserFixed-93))|(1<<(SolidityParserUfixed-93))|(1<<(SolidityParserBooleanLiteral-93))|(1<<(SolidityParserDecimalNumber-93))|(1<<(SolidityParserHexNumber-93))|(1<<(SolidityParserHexLiteralFragment-93))|(1<<(SolidityParserPayableKeyword-93))|(1<<(SolidityParserTypeKeyword-93))|(1<<(SolidityParserIdentifier-93))|(1<<(SolidityParserStringLiteralFragment-93)))) != 0) {
			{
				p.SetState(876)
				p.expression(0)
			}
			p.SetState(881)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SolidityParserT__14 {
				{
					p.SetState(877)
					p.Match(SolidityParserT__14)
				}
				{
					p.SetState(878)
					p.expression(0)
				}

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

		}
		{
			p.SetState(886)
			p.Match(SolidityParserT__33)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeNameExpressionContext() *TypeNameExpressionContext {
	var p = new(TypeNameExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_typeNameExpression
	return p
}

func (*TypeNameExpressionContext) IsTypeNameExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_typeNameExpression

	return p
}

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

func (s *TypeNameExpressionContext) ElementaryTypeName() IElementaryTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementaryTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementaryTypeNameContext)
}

func (s *TypeNameExpressionContext) UserDefinedTypeName() IUserDefinedTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserDefinedTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserDefinedTypeNameContext)
}

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

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

func (s *TypeNameExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterTypeNameExpression(s)
	}
}

func (s *TypeNameExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitTypeNameExpression(s)
	}
}

func (p *SolidityParser) TypeNameExpression() (localctx ITypeNameExpressionContext) {
	this := p
	_ = this

	localctx = NewTypeNameExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, SolidityParserRULE_typeNameExpression)

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

	defer func() {
		if err := recover(); err != 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(891)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(889)
			p.ElementaryTypeName()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(890)
			p.UserDefinedTypeName()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyItemContext() *AssemblyItemContext {
	var p = new(AssemblyItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyItem
	return p
}

func (*AssemblyItemContext) IsAssemblyItemContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyItem

	return p
}

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

func (s *AssemblyItemContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AssemblyItemContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *AssemblyItemContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

func (s *AssemblyItemContext) AssemblyLocalDefinition() IAssemblyLocalDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyLocalDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyLocalDefinitionContext)
}

func (s *AssemblyItemContext) AssemblyAssignment() IAssemblyAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyAssignmentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyAssignmentContext)
}

func (s *AssemblyItemContext) AssemblyStackAssignment() IAssemblyStackAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyStackAssignmentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyStackAssignmentContext)
}

func (s *AssemblyItemContext) LabelDefinition() ILabelDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILabelDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILabelDefinitionContext)
}

func (s *AssemblyItemContext) AssemblySwitch() IAssemblySwitchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblySwitchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblySwitchContext)
}

func (s *AssemblyItemContext) AssemblyFunctionDefinition() IAssemblyFunctionDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyFunctionDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyFunctionDefinitionContext)
}

func (s *AssemblyItemContext) AssemblyFor() IAssemblyForContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyForContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyForContext)
}

func (s *AssemblyItemContext) AssemblyIf() IAssemblyIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyIfContext)
}

func (s *AssemblyItemContext) BreakKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserBreakKeyword, 0)
}

func (s *AssemblyItemContext) ContinueKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserContinueKeyword, 0)
}

func (s *AssemblyItemContext) LeaveKeyword() antlr.TerminalNode {
	return s.GetToken(SolidityParserLeaveKeyword, 0)
}

func (s *AssemblyItemContext) SubAssembly() ISubAssemblyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubAssemblyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISubAssemblyContext)
}

func (s *AssemblyItemContext) NumberLiteral() INumberLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumberLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumberLiteralContext)
}

func (s *AssemblyItemContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *AssemblyItemContext) HexLiteral() IHexLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IHexLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IHexLiteralContext)
}

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

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

func (s *AssemblyItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyItem(s)
	}
}

func (s *AssemblyItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyItem(s)
	}
}

func (p *SolidityParser) AssemblyItem() (localctx IAssemblyItemContext) {
	this := p
	_ = this

	localctx = NewAssemblyItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, SolidityParserRULE_assemblyItem)

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

	defer func() {
		if err := recover(); err != 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(911)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(893)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(894)
			p.AssemblyBlock()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(895)
			p.AssemblyExpression()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(896)
			p.AssemblyLocalDefinition()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(897)
			p.AssemblyAssignment()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(898)
			p.AssemblyStackAssignment()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(899)
			p.LabelDefinition()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(900)
			p.AssemblySwitch()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(901)
			p.AssemblyFunctionDefinition()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(902)
			p.AssemblyFor()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(903)
			p.AssemblyIf()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(904)
			p.Match(SolidityParserBreakKeyword)
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(905)
			p.Match(SolidityParserContinueKeyword)
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(906)
			p.Match(SolidityParserLeaveKeyword)
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(907)
			p.SubAssembly()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(908)
			p.NumberLiteral()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(909)
			p.StringLiteral()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(910)
			p.HexLiteral()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyBlockContext() *AssemblyBlockContext {
	var p = new(AssemblyBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyBlock
	return p
}

func (*AssemblyBlockContext) IsAssemblyBlockContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyBlock

	return p
}

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

func (s *AssemblyBlockContext) AllAssemblyItem() []IAssemblyItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssemblyItemContext)(nil)).Elem())
	var tst = make([]IAssemblyItemContext, len(ts))

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

	return tst
}

func (s *AssemblyBlockContext) AssemblyItem(i int) IAssemblyItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssemblyItemContext)
}

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

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

func (s *AssemblyBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyBlock(s)
	}
}

func (s *AssemblyBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyBlock(s)
	}
}

func (p *SolidityParser) AssemblyBlock() (localctx IAssemblyBlockContext) {
	this := p
	_ = this

	localctx = NewAssemblyBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, SolidityParserRULE_assemblyBlock)
	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(913)
		p.Match(SolidityParserT__13)
	}
	p.SetState(917)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SolidityParserT__12)|(1<<SolidityParserT__13)|(1<<SolidityParserT__25)|(1<<SolidityParserT__28))) != 0) || (((_la-40)&-(0x1f+1)) == 0 && ((1<<uint((_la-40)))&((1<<(SolidityParserT__39-40))|(1<<(SolidityParserT__40-40))|(1<<(SolidityParserT__45-40))|(1<<(SolidityParserT__47-40))|(1<<(SolidityParserT__51-40))|(1<<(SolidityParserT__54-40)))) != 0) || (((_la-87)&-(0x1f+1)) == 0 && ((1<<uint((_la-87)))&((1<<(SolidityParserT__86-87))|(1<<(SolidityParserT__88-87))|(1<<(SolidityParserT__89-87))|(1<<(SolidityParserBooleanLiteral-87))|(1<<(SolidityParserDecimalNumber-87))|(1<<(SolidityParserHexNumber-87))|(1<<(SolidityParserHexLiteralFragment-87))|(1<<(SolidityParserBreakKeyword-87))|(1<<(SolidityParserContinueKeyword-87))|(1<<(SolidityParserLeaveKeyword-87)))) != 0) || _la == SolidityParserIdentifier || _la == SolidityParserStringLiteralFragment {
		{
			p.SetState(914)
			p.AssemblyItem()
		}

		p.SetState(919)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(920)
		p.Match(SolidityParserT__15)
	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyExpressionContext() *AssemblyExpressionContext {
	var p = new(AssemblyExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyExpression
	return p
}

func (*AssemblyExpressionContext) IsAssemblyExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyExpression

	return p
}

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

func (s *AssemblyExpressionContext) AssemblyCall() IAssemblyCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyCallContext)
}

func (s *AssemblyExpressionContext) AssemblyLiteral() IAssemblyLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyLiteralContext)
}

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

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

func (s *AssemblyExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyExpression(s)
	}
}

func (s *AssemblyExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyExpression(s)
	}
}

func (p *SolidityParser) AssemblyExpression() (localctx IAssemblyExpressionContext) {
	this := p
	_ = this

	localctx = NewAssemblyExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, SolidityParserRULE_assemblyExpression)

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

	defer func() {
		if err := recover(); err != 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(924)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__12, SolidityParserT__39, SolidityParserT__47, SolidityParserT__51, SolidityParserT__54, SolidityParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(922)
			p.AssemblyCall()
		}

	case SolidityParserBooleanLiteral, SolidityParserDecimalNumber, SolidityParserHexNumber, SolidityParserHexLiteralFragment, SolidityParserStringLiteralFragment:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(923)
			p.AssemblyLiteral()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAssemblyCallContext() *AssemblyCallContext {
	var p = new(AssemblyCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyCall
	return p
}

func (*AssemblyCallContext) IsAssemblyCallContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyCall

	return p
}

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

func (s *AssemblyCallContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AssemblyCallContext) AllAssemblyExpression() []IAssemblyExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem())
	var tst = make([]IAssemblyExpressionContext, len(ts))

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

	return tst
}

func (s *AssemblyCallContext) AssemblyExpression(i int) IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

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

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

func (s *AssemblyCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyCall(s)
	}
}

func (s *AssemblyCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyCall(s)
	}
}

func (p *SolidityParser) AssemblyCall() (localctx IAssemblyCallContext) {
	this := p
	_ = this

	localctx = NewAssemblyCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, SolidityParserRULE_assemblyCall)
	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(930)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(926)
			p.Match(SolidityParserT__47)
		}

	case 2:
		{
			p.SetState(927)
			p.Match(SolidityParserT__51)
		}

	case 3:
		{
			p.SetState(928)
			p.Match(SolidityParserT__54)
		}

	case 4:
		{
			p.SetState(929)
			p.Identifier()
		}

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

	if _la == SolidityParserT__21 {
		{
			p.SetState(932)
			p.Match(SolidityParserT__21)
		}
		p.SetState(934)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__12 || (((_la-40)&-(0x1f+1)) == 0 && ((1<<uint((_la-40)))&((1<<(SolidityParserT__39-40))|(1<<(SolidityParserT__47-40))|(1<<(SolidityParserT__51-40))|(1<<(SolidityParserT__54-40)))) != 0) || (((_la-98)&-(0x1f+1)) == 0 && ((1<<uint((_la-98)))&((1<<(SolidityParserBooleanLiteral-98))|(1<<(SolidityParserDecimalNumber-98))|(1<<(SolidityParserHexNumber-98))|(1<<(SolidityParserHexLiteralFragment-98))|(1<<(SolidityParserIdentifier-98))|(1<<(SolidityParserStringLiteralFragment-98)))) != 0) {
			{
				p.SetState(933)
				p.AssemblyExpression()
			}

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

		for _la == SolidityParserT__14 {
			{
				p.SetState(936)
				p.Match(SolidityParserT__14)
			}
			{
				p.SetState(937)
				p.AssemblyExpression()
			}

			p.SetState(942)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(943)
			p.Match(SolidityParserT__22)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyLocalDefinitionContext() *AssemblyLocalDefinitionContext {
	var p = new(AssemblyLocalDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyLocalDefinition
	return p
}

func (*AssemblyLocalDefinitionContext) IsAssemblyLocalDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyLocalDefinition

	return p
}

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

func (s *AssemblyLocalDefinitionContext) AssemblyIdentifierList() IAssemblyIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyIdentifierListContext)
}

func (s *AssemblyLocalDefinitionContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

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

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

func (s *AssemblyLocalDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyLocalDefinition(s)
	}
}

func (s *AssemblyLocalDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyLocalDefinition(s)
	}
}

func (p *SolidityParser) AssemblyLocalDefinition() (localctx IAssemblyLocalDefinitionContext) {
	this := p
	_ = this

	localctx = NewAssemblyLocalDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, SolidityParserRULE_assemblyLocalDefinition)
	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(946)
		p.Match(SolidityParserT__86)
	}
	{
		p.SetState(947)
		p.AssemblyIdentifierList()
	}
	p.SetState(950)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__87 {
		{
			p.SetState(948)
			p.Match(SolidityParserT__87)
		}
		{
			p.SetState(949)
			p.AssemblyExpression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyAssignmentContext() *AssemblyAssignmentContext {
	var p = new(AssemblyAssignmentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyAssignment
	return p
}

func (*AssemblyAssignmentContext) IsAssemblyAssignmentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyAssignment

	return p
}

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

func (s *AssemblyAssignmentContext) AssemblyIdentifierList() IAssemblyIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyIdentifierListContext)
}

func (s *AssemblyAssignmentContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

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

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

func (s *AssemblyAssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyAssignment(s)
	}
}

func (s *AssemblyAssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyAssignment(s)
	}
}

func (p *SolidityParser) AssemblyAssignment() (localctx IAssemblyAssignmentContext) {
	this := p
	_ = this

	localctx = NewAssemblyAssignmentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, SolidityParserRULE_assemblyAssignment)

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

	defer func() {
		if err := recover(); err != 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(952)
		p.AssemblyIdentifierList()
	}
	{
		p.SetState(953)
		p.Match(SolidityParserT__87)
	}
	{
		p.SetState(954)
		p.AssemblyExpression()
	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyIdentifierListContext() *AssemblyIdentifierListContext {
	var p = new(AssemblyIdentifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyIdentifierList
	return p
}

func (*AssemblyIdentifierListContext) IsAssemblyIdentifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyIdentifierList

	return p
}

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

func (s *AssemblyIdentifierListContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *AssemblyIdentifierListContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *AssemblyIdentifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyIdentifierList(s)
	}
}

func (s *AssemblyIdentifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyIdentifierList(s)
	}
}

func (p *SolidityParser) AssemblyIdentifierList() (localctx IAssemblyIdentifierListContext) {
	this := p
	_ = this

	localctx = NewAssemblyIdentifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, SolidityParserRULE_assemblyIdentifierList)
	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(956)
		p.Identifier()
	}
	p.SetState(961)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SolidityParserT__14 {
		{
			p.SetState(957)
			p.Match(SolidityParserT__14)
		}
		{
			p.SetState(958)
			p.Identifier()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAssemblyStackAssignmentContext() *AssemblyStackAssignmentContext {
	var p = new(AssemblyStackAssignmentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyStackAssignment
	return p
}

func (*AssemblyStackAssignmentContext) IsAssemblyStackAssignmentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyStackAssignment

	return p
}

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

func (s *AssemblyStackAssignmentContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *AssemblyStackAssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyStackAssignment(s)
	}
}

func (s *AssemblyStackAssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyStackAssignment(s)
	}
}

func (p *SolidityParser) AssemblyStackAssignment() (localctx IAssemblyStackAssignmentContext) {
	this := p
	_ = this

	localctx = NewAssemblyStackAssignmentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, SolidityParserRULE_assemblyStackAssignment)

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

	defer func() {
		if err := recover(); err != 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(964)
		p.Match(SolidityParserT__88)
	}
	{
		p.SetState(965)
		p.Identifier()
	}

	return localctx
}

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

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

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

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

func NewEmptyLabelDefinitionContext() *LabelDefinitionContext {
	var p = new(LabelDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_labelDefinition
	return p
}

func (*LabelDefinitionContext) IsLabelDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_labelDefinition

	return p
}

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

func (s *LabelDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

func (s *LabelDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterLabelDefinition(s)
	}
}

func (s *LabelDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitLabelDefinition(s)
	}
}

func (p *SolidityParser) LabelDefinition() (localctx ILabelDefinitionContext) {
	this := p
	_ = this

	localctx = NewLabelDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, SolidityParserRULE_labelDefinition)

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

	defer func() {
		if err := recover(); err != 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(967)
		p.Identifier()
	}
	{
		p.SetState(968)
		p.Match(SolidityParserT__58)
	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblySwitchContext() *AssemblySwitchContext {
	var p = new(AssemblySwitchContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblySwitch
	return p
}

func (*AssemblySwitchContext) IsAssemblySwitchContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblySwitch

	return p
}

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

func (s *AssemblySwitchContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

func (s *AssemblySwitchContext) AllAssemblyCase() []IAssemblyCaseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssemblyCaseContext)(nil)).Elem())
	var tst = make([]IAssemblyCaseContext, len(ts))

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

	return tst
}

func (s *AssemblySwitchContext) AssemblyCase(i int) IAssemblyCaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyCaseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssemblyCaseContext)
}

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

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

func (s *AssemblySwitchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblySwitch(s)
	}
}

func (s *AssemblySwitchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblySwitch(s)
	}
}

func (p *SolidityParser) AssemblySwitch() (localctx IAssemblySwitchContext) {
	this := p
	_ = this

	localctx = NewAssemblySwitchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, SolidityParserRULE_assemblySwitch)
	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(970)
		p.Match(SolidityParserT__89)
	}
	{
		p.SetState(971)
		p.AssemblyExpression()
	}
	p.SetState(975)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SolidityParserT__90 || _la == SolidityParserT__91 {
		{
			p.SetState(972)
			p.AssemblyCase()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAssemblyCaseContext() *AssemblyCaseContext {
	var p = new(AssemblyCaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyCase
	return p
}

func (*AssemblyCaseContext) IsAssemblyCaseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyCase

	return p
}

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

func (s *AssemblyCaseContext) AssemblyLiteral() IAssemblyLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyLiteralContext)
}

func (s *AssemblyCaseContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *AssemblyCaseContext) AssemblyType() IAssemblyTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypeContext)
}

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

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

func (s *AssemblyCaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyCase(s)
	}
}

func (s *AssemblyCaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyCase(s)
	}
}

func (p *SolidityParser) AssemblyCase() (localctx IAssemblyCaseContext) {
	this := p
	_ = this

	localctx = NewAssemblyCaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, SolidityParserRULE_assemblyCase)
	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(987)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserT__90:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(978)
			p.Match(SolidityParserT__90)
		}
		{
			p.SetState(979)
			p.AssemblyLiteral()
		}
		p.SetState(981)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SolidityParserT__58 {
			{
				p.SetState(980)
				p.AssemblyType()
			}

		}
		{
			p.SetState(983)
			p.AssemblyBlock()
		}

	case SolidityParserT__91:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(985)
			p.Match(SolidityParserT__91)
		}
		{
			p.SetState(986)
			p.AssemblyBlock()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAssemblyFunctionDefinitionContext() *AssemblyFunctionDefinitionContext {
	var p = new(AssemblyFunctionDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyFunctionDefinition
	return p
}

func (*AssemblyFunctionDefinitionContext) IsAssemblyFunctionDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyFunctionDefinition

	return p
}

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

func (s *AssemblyFunctionDefinitionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AssemblyFunctionDefinitionContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *AssemblyFunctionDefinitionContext) AssemblyTypedVariableList() IAssemblyTypedVariableListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypedVariableListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypedVariableListContext)
}

func (s *AssemblyFunctionDefinitionContext) AssemblyFunctionReturns() IAssemblyFunctionReturnsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyFunctionReturnsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyFunctionReturnsContext)
}

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

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

func (s *AssemblyFunctionDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyFunctionDefinition(s)
	}
}

func (s *AssemblyFunctionDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyFunctionDefinition(s)
	}
}

func (p *SolidityParser) AssemblyFunctionDefinition() (localctx IAssemblyFunctionDefinitionContext) {
	this := p
	_ = this

	localctx = NewAssemblyFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, SolidityParserRULE_assemblyFunctionDefinition)
	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(989)
		p.Match(SolidityParserT__28)
	}
	{
		p.SetState(990)
		p.Identifier()
	}
	{
		p.SetState(991)
		p.Match(SolidityParserT__21)
	}
	p.SetState(993)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier {
		{
			p.SetState(992)
			p.AssemblyTypedVariableList()
		}

	}
	{
		p.SetState(995)
		p.Match(SolidityParserT__22)
	}
	p.SetState(997)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__60 {
		{
			p.SetState(996)
			p.AssemblyFunctionReturns()
		}

	}
	{
		p.SetState(999)
		p.AssemblyBlock()
	}

	return localctx
}

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

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

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

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

func NewEmptyAssemblyFunctionReturnsContext() *AssemblyFunctionReturnsContext {
	var p = new(AssemblyFunctionReturnsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyFunctionReturns
	return p
}

func (*AssemblyFunctionReturnsContext) IsAssemblyFunctionReturnsContext() {}

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

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyFunctionReturns

	return p
}

func (s *AssemblyFunctionReturnsContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyFunctionReturnsContext) AssemblyTypedVariableList() IAssemblyTypedVariableListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypedVariableListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypedVariableListContext)
}

func (s *AssemblyFunctionReturnsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyFunctionReturnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyFunctionReturnsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyFunctionReturns(s)
	}
}

func (s *AssemblyFunctionReturnsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyFunctionReturns(s)
	}
}

func (p *SolidityParser) AssemblyFunctionReturns() (localctx IAssemblyFunctionReturnsContext) {
	this := p
	_ = this

	localctx = NewAssemblyFunctionReturnsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, SolidityParserRULE_assemblyFunctionReturns)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1001)
		p.Match(SolidityParserT__60)
	}
	{
		p.SetState(1002)
		p.Match(SolidityParserT__5)
	}
	{
		p.SetState(1003)
		p.AssemblyTypedVariableList()
	}

	return localctx
}

// IAssemblyForContext is an interface to support dynamic dispatch.
type IAssemblyForContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssemblyForContext differentiates from other interfaces.
	IsAssemblyForContext()
}

type AssemblyForContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssemblyForContext() *AssemblyForContext {
	var p = new(AssemblyForContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyFor
	return p
}

func (*AssemblyForContext) IsAssemblyForContext() {}

func NewAssemblyForContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssemblyForContext {
	var p = new(AssemblyForContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyFor

	return p
}

func (s *AssemblyForContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyForContext) AllAssemblyBlock() []IAssemblyBlockContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem())
	var tst = make([]IAssemblyBlockContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAssemblyBlockContext)
		}
	}

	return tst
}

func (s *AssemblyForContext) AssemblyBlock(i int) IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *AssemblyForContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

func (s *AssemblyForContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyForContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyForContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyFor(s)
	}
}

func (s *AssemblyForContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyFor(s)
	}
}

func (p *SolidityParser) AssemblyFor() (localctx IAssemblyForContext) {
	this := p
	_ = this

	localctx = NewAssemblyForContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, SolidityParserRULE_assemblyFor)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1005)
		p.Match(SolidityParserT__25)
	}
	{
		p.SetState(1006)
		p.AssemblyBlock()
	}
	{
		p.SetState(1007)
		p.AssemblyExpression()
	}
	{
		p.SetState(1008)
		p.AssemblyBlock()
	}
	{
		p.SetState(1009)
		p.AssemblyBlock()
	}

	return localctx
}

// IAssemblyIfContext is an interface to support dynamic dispatch.
type IAssemblyIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssemblyIfContext differentiates from other interfaces.
	IsAssemblyIfContext()
}

type AssemblyIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssemblyIfContext() *AssemblyIfContext {
	var p = new(AssemblyIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyIf
	return p
}

func (*AssemblyIfContext) IsAssemblyIfContext() {}

func NewAssemblyIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssemblyIfContext {
	var p = new(AssemblyIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyIf

	return p
}

func (s *AssemblyIfContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyIfContext) AssemblyExpression() IAssemblyExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyExpressionContext)
}

func (s *AssemblyIfContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *AssemblyIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyIf(s)
	}
}

func (s *AssemblyIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyIf(s)
	}
}

func (p *SolidityParser) AssemblyIf() (localctx IAssemblyIfContext) {
	this := p
	_ = this

	localctx = NewAssemblyIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, SolidityParserRULE_assemblyIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1011)
		p.Match(SolidityParserT__40)
	}
	{
		p.SetState(1012)
		p.AssemblyExpression()
	}
	{
		p.SetState(1013)
		p.AssemblyBlock()
	}

	return localctx
}

// IAssemblyLiteralContext is an interface to support dynamic dispatch.
type IAssemblyLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssemblyLiteralContext differentiates from other interfaces.
	IsAssemblyLiteralContext()
}

type AssemblyLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssemblyLiteralContext() *AssemblyLiteralContext {
	var p = new(AssemblyLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyLiteral
	return p
}

func (*AssemblyLiteralContext) IsAssemblyLiteralContext() {}

func NewAssemblyLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssemblyLiteralContext {
	var p = new(AssemblyLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyLiteral

	return p
}

func (s *AssemblyLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyLiteralContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *AssemblyLiteralContext) DecimalNumber() antlr.TerminalNode {
	return s.GetToken(SolidityParserDecimalNumber, 0)
}

func (s *AssemblyLiteralContext) HexNumber() antlr.TerminalNode {
	return s.GetToken(SolidityParserHexNumber, 0)
}

func (s *AssemblyLiteralContext) HexLiteral() IHexLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IHexLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IHexLiteralContext)
}

func (s *AssemblyLiteralContext) BooleanLiteral() antlr.TerminalNode {
	return s.GetToken(SolidityParserBooleanLiteral, 0)
}

func (s *AssemblyLiteralContext) AssemblyType() IAssemblyTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypeContext)
}

func (s *AssemblyLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyLiteral(s)
	}
}

func (s *AssemblyLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyLiteral(s)
	}
}

func (p *SolidityParser) AssemblyLiteral() (localctx IAssemblyLiteralContext) {
	this := p
	_ = this

	localctx = NewAssemblyLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, SolidityParserRULE_assemblyLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1020)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SolidityParserStringLiteralFragment:
		{
			p.SetState(1015)
			p.StringLiteral()
		}

	case SolidityParserDecimalNumber:
		{
			p.SetState(1016)
			p.Match(SolidityParserDecimalNumber)
		}

	case SolidityParserHexNumber:
		{
			p.SetState(1017)
			p.Match(SolidityParserHexNumber)
		}

	case SolidityParserHexLiteralFragment:
		{
			p.SetState(1018)
			p.HexLiteral()
		}

	case SolidityParserBooleanLiteral:
		{
			p.SetState(1019)
			p.Match(SolidityParserBooleanLiteral)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(1023)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1022)
			p.AssemblyType()
		}

	}

	return localctx
}

// IAssemblyTypedVariableListContext is an interface to support dynamic dispatch.
type IAssemblyTypedVariableListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssemblyTypedVariableListContext differentiates from other interfaces.
	IsAssemblyTypedVariableListContext()
}

type AssemblyTypedVariableListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssemblyTypedVariableListContext() *AssemblyTypedVariableListContext {
	var p = new(AssemblyTypedVariableListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyTypedVariableList
	return p
}

func (*AssemblyTypedVariableListContext) IsAssemblyTypedVariableListContext() {}

func NewAssemblyTypedVariableListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssemblyTypedVariableListContext {
	var p = new(AssemblyTypedVariableListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyTypedVariableList

	return p
}

func (s *AssemblyTypedVariableListContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyTypedVariableListContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AssemblyTypedVariableListContext) AssemblyType() IAssemblyTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypeContext)
}

func (s *AssemblyTypedVariableListContext) AssemblyTypedVariableList() IAssemblyTypedVariableListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyTypedVariableListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyTypedVariableListContext)
}

func (s *AssemblyTypedVariableListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyTypedVariableListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyTypedVariableListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyTypedVariableList(s)
	}
}

func (s *AssemblyTypedVariableListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyTypedVariableList(s)
	}
}

func (p *SolidityParser) AssemblyTypedVariableList() (localctx IAssemblyTypedVariableListContext) {
	this := p
	_ = this

	localctx = NewAssemblyTypedVariableListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, SolidityParserRULE_assemblyTypedVariableList)
	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(1025)
		p.Identifier()
	}
	p.SetState(1027)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__58 {
		{
			p.SetState(1026)
			p.AssemblyType()
		}

	}
	p.SetState(1031)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SolidityParserT__14 {
		{
			p.SetState(1029)
			p.Match(SolidityParserT__14)
		}
		{
			p.SetState(1030)
			p.AssemblyTypedVariableList()
		}

	}

	return localctx
}

// IAssemblyTypeContext is an interface to support dynamic dispatch.
type IAssemblyTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssemblyTypeContext differentiates from other interfaces.
	IsAssemblyTypeContext()
}

type AssemblyTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssemblyTypeContext() *AssemblyTypeContext {
	var p = new(AssemblyTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_assemblyType
	return p
}

func (*AssemblyTypeContext) IsAssemblyTypeContext() {}

func NewAssemblyTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssemblyTypeContext {
	var p = new(AssemblyTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_assemblyType

	return p
}

func (s *AssemblyTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *AssemblyTypeContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *AssemblyTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssemblyTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssemblyTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterAssemblyType(s)
	}
}

func (s *AssemblyTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitAssemblyType(s)
	}
}

func (p *SolidityParser) AssemblyType() (localctx IAssemblyTypeContext) {
	this := p
	_ = this

	localctx = NewAssemblyTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, SolidityParserRULE_assemblyType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1033)
		p.Match(SolidityParserT__58)
	}
	{
		p.SetState(1034)
		p.Identifier()
	}

	return localctx
}

// ISubAssemblyContext is an interface to support dynamic dispatch.
type ISubAssemblyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubAssemblyContext differentiates from other interfaces.
	IsSubAssemblyContext()
}

type SubAssemblyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubAssemblyContext() *SubAssemblyContext {
	var p = new(SubAssemblyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_subAssembly
	return p
}

func (*SubAssemblyContext) IsSubAssemblyContext() {}

func NewSubAssemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubAssemblyContext {
	var p = new(SubAssemblyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_subAssembly

	return p
}

func (s *SubAssemblyContext) GetParser() antlr.Parser { return s.parser }

func (s *SubAssemblyContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *SubAssemblyContext) AssemblyBlock() IAssemblyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssemblyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssemblyBlockContext)
}

func (s *SubAssemblyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SubAssemblyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SubAssemblyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterSubAssembly(s)
	}
}

func (s *SubAssemblyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitSubAssembly(s)
	}
}

func (p *SolidityParser) SubAssembly() (localctx ISubAssemblyContext) {
	this := p
	_ = this

	localctx = NewSubAssemblyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, SolidityParserRULE_subAssembly)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1036)
		p.Match(SolidityParserT__45)
	}
	{
		p.SetState(1037)
		p.Identifier()
	}
	{
		p.SetState(1038)
		p.AssemblyBlock()
	}

	return localctx
}

// INumberLiteralContext is an interface to support dynamic dispatch.
type INumberLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNumberLiteralContext differentiates from other interfaces.
	IsNumberLiteralContext()
}

type NumberLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumberLiteralContext() *NumberLiteralContext {
	var p = new(NumberLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_numberLiteral
	return p
}

func (*NumberLiteralContext) IsNumberLiteralContext() {}

func NewNumberLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberLiteralContext {
	var p = new(NumberLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_numberLiteral

	return p
}

func (s *NumberLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *NumberLiteralContext) DecimalNumber() antlr.TerminalNode {
	return s.GetToken(SolidityParserDecimalNumber, 0)
}

func (s *NumberLiteralContext) HexNumber() antlr.TerminalNode {
	return s.GetToken(SolidityParserHexNumber, 0)
}

func (s *NumberLiteralContext) NumberUnit() antlr.TerminalNode {
	return s.GetToken(SolidityParserNumberUnit, 0)
}

func (s *NumberLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NumberLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NumberLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterNumberLiteral(s)
	}
}

func (s *NumberLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitNumberLiteral(s)
	}
}

func (p *SolidityParser) NumberLiteral() (localctx INumberLiteralContext) {
	this := p
	_ = this

	localctx = NewNumberLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, SolidityParserRULE_numberLiteral)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1040)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SolidityParserDecimalNumber || _la == SolidityParserHexNumber) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1042)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1041)
			p.Match(SolidityParserNumberUnit)
		}

	}

	return localctx
}

// IIdentifierContext is an interface to support dynamic dispatch.
type IIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIdentifierContext differentiates from other interfaces.
	IsIdentifierContext()
}

type IdentifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIdentifierContext() *IdentifierContext {
	var p = new(IdentifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_identifier
	return p
}

func (*IdentifierContext) IsIdentifierContext() {}

func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext {
	var p = new(IdentifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_identifier

	return p
}

func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser }

func (s *IdentifierContext) Identifier() antlr.TerminalNode {
	return s.GetToken(SolidityParserIdentifier, 0)
}

func (s *IdentifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterIdentifier(s)
	}
}

func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitIdentifier(s)
	}
}

func (p *SolidityParser) Identifier() (localctx IIdentifierContext) {
	this := p
	_ = this

	localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, SolidityParserRULE_identifier)
	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(1044)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SolidityParserT__12 || _la == SolidityParserT__39 || _la == SolidityParserT__51 || _la == SolidityParserIdentifier) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IHexLiteralContext is an interface to support dynamic dispatch.
type IHexLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsHexLiteralContext differentiates from other interfaces.
	IsHexLiteralContext()
}

type HexLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHexLiteralContext() *HexLiteralContext {
	var p = new(HexLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_hexLiteral
	return p
}

func (*HexLiteralContext) IsHexLiteralContext() {}

func NewHexLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexLiteralContext {
	var p = new(HexLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_hexLiteral

	return p
}

func (s *HexLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *HexLiteralContext) AllHexLiteralFragment() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserHexLiteralFragment)
}

func (s *HexLiteralContext) HexLiteralFragment(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserHexLiteralFragment, i)
}

func (s *HexLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *HexLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *HexLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterHexLiteral(s)
	}
}

func (s *HexLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitHexLiteral(s)
	}
}

func (p *SolidityParser) HexLiteral() (localctx IHexLiteralContext) {
	this := p
	_ = this

	localctx = NewHexLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, SolidityParserRULE_hexLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1047)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(1046)
				p.Match(SolidityParserHexLiteralFragment)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(1049)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 120, p.GetParserRuleContext())
	}

	return localctx
}

// IStringLiteralContext is an interface to support dynamic dispatch.
type IStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStringLiteralContext differentiates from other interfaces.
	IsStringLiteralContext()
}

type StringLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStringLiteralContext() *StringLiteralContext {
	var p = new(StringLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SolidityParserRULE_stringLiteral
	return p
}

func (*StringLiteralContext) IsStringLiteralContext() {}

func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext {
	var p = new(StringLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SolidityParserRULE_stringLiteral

	return p
}

func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *StringLiteralContext) AllStringLiteralFragment() []antlr.TerminalNode {
	return s.GetTokens(SolidityParserStringLiteralFragment)
}

func (s *StringLiteralContext) StringLiteralFragment(i int) antlr.TerminalNode {
	return s.GetToken(SolidityParserStringLiteralFragment, i)
}

func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.EnterStringLiteral(s)
	}
}

func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SolidityListener); ok {
		listenerT.ExitStringLiteral(s)
	}
}

func (p *SolidityParser) StringLiteral() (localctx IStringLiteralContext) {
	this := p
	_ = this

	localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, SolidityParserRULE_stringLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1052)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(1051)
				p.Match(SolidityParserStringLiteralFragment)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(1054)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 121, p.GetParserRuleContext())
	}

	return localctx
}

func (p *SolidityParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 30:
		var t *TypeNameContext = nil
		if localctx != nil {
			t = localctx.(*TypeNameContext)
		}
		return p.TypeName_Sempred(t, predIndex)

	case 56:
		var t *ExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ExpressionContext)
		}
		return p.Expression_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *SolidityParser) TypeName_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *SolidityParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 1:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 13)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 9)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 14:
		return p.Precpred(p.GetParserRuleContext(), 28)

	case 15:
		return p.Precpred(p.GetParserRuleContext(), 26)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 25)

	case 17:
		return p.Precpred(p.GetParserRuleContext(), 24)

	case 18:
		return p.Precpred(p.GetParserRuleContext(), 23)

	case 19:
		return p.Precpred(p.GetParserRuleContext(), 22)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
