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

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

var ruleNames = []string{
	"stored_definition", "class_definition", "class_specifier", "class_prefixes",
	"long_class_specifier", "short_class_specifier", "der_class_specifier",
	"base_prefix", "enum_list", "enumeration_literal", "composition", "language_specification",
	"external_function_call", "element_list", "element", "import_clause", "import_list",
	"extends_clause", "constraining_clause", "component_clause", "type_prefix",
	"type_specifier", "component_list", "component_declaration", "condition_attribute",
	"declaration", "modification", "class_modification", "argument_list", "argument",
	"element_modification_or_replaceable", "element_modification", "element_redeclaration",
	"element_replaceable", "component_clause1", "component_declaration1", "short_class_definition",
	"equation_section", "algorithm_section", "equation", "statement", "if_equation",
	"if_statement", "for_equation", "for_statement", "for_indices", "for_index",
	"while_statement", "when_equation", "when_statement", "connect_clause",
	"expression", "simple_expression", "logical_expression", "logical_term",
	"logical_factor", "relation", "rel_op", "arithmetic_expression", "add_op",
	"term", "mul_op", "factor", "primary", "name", "component_reference", "function_call_args",
	"function_arguments", "named_arguments", "named_argument", "function_argument",
	"output_expression_list", "expression_list", "array_subscripts", "subscript_",
	"comment", "string_comment", "annotation",
}

type modelicaParser struct {
	*antlr.BaseParser
}

// NewmodelicaParser produces a new parser instance for the optional input antlr.TokenStream.
//
// The *modelicaParser 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 NewmodelicaParser(input antlr.TokenStream) *modelicaParser {
	this := new(modelicaParser)
	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 = "modelica.g4"

	return this
}

// modelicaParser tokens.
const (
	modelicaParserEOF             = antlr.TokenEOF
	modelicaParserT__0            = 1
	modelicaParserT__1            = 2
	modelicaParserT__2            = 3
	modelicaParserT__3            = 4
	modelicaParserT__4            = 5
	modelicaParserT__5            = 6
	modelicaParserT__6            = 7
	modelicaParserT__7            = 8
	modelicaParserT__8            = 9
	modelicaParserT__9            = 10
	modelicaParserT__10           = 11
	modelicaParserT__11           = 12
	modelicaParserT__12           = 13
	modelicaParserT__13           = 14
	modelicaParserT__14           = 15
	modelicaParserT__15           = 16
	modelicaParserT__16           = 17
	modelicaParserT__17           = 18
	modelicaParserT__18           = 19
	modelicaParserT__19           = 20
	modelicaParserT__20           = 21
	modelicaParserT__21           = 22
	modelicaParserT__22           = 23
	modelicaParserT__23           = 24
	modelicaParserT__24           = 25
	modelicaParserT__25           = 26
	modelicaParserT__26           = 27
	modelicaParserT__27           = 28
	modelicaParserT__28           = 29
	modelicaParserT__29           = 30
	modelicaParserT__30           = 31
	modelicaParserT__31           = 32
	modelicaParserT__32           = 33
	modelicaParserT__33           = 34
	modelicaParserT__34           = 35
	modelicaParserT__35           = 36
	modelicaParserT__36           = 37
	modelicaParserT__37           = 38
	modelicaParserT__38           = 39
	modelicaParserT__39           = 40
	modelicaParserT__40           = 41
	modelicaParserT__41           = 42
	modelicaParserT__42           = 43
	modelicaParserT__43           = 44
	modelicaParserT__44           = 45
	modelicaParserT__45           = 46
	modelicaParserT__46           = 47
	modelicaParserT__47           = 48
	modelicaParserT__48           = 49
	modelicaParserT__49           = 50
	modelicaParserT__50           = 51
	modelicaParserT__51           = 52
	modelicaParserT__52           = 53
	modelicaParserT__53           = 54
	modelicaParserT__54           = 55
	modelicaParserT__55           = 56
	modelicaParserT__56           = 57
	modelicaParserT__57           = 58
	modelicaParserT__58           = 59
	modelicaParserT__59           = 60
	modelicaParserT__60           = 61
	modelicaParserT__61           = 62
	modelicaParserT__62           = 63
	modelicaParserT__63           = 64
	modelicaParserT__64           = 65
	modelicaParserT__65           = 66
	modelicaParserT__66           = 67
	modelicaParserT__67           = 68
	modelicaParserT__68           = 69
	modelicaParserT__69           = 70
	modelicaParserT__70           = 71
	modelicaParserT__71           = 72
	modelicaParserT__72           = 73
	modelicaParserT__73           = 74
	modelicaParserT__74           = 75
	modelicaParserT__75           = 76
	modelicaParserT__76           = 77
	modelicaParserT__77           = 78
	modelicaParserT__78           = 79
	modelicaParserT__79           = 80
	modelicaParserT__80           = 81
	modelicaParserT__81           = 82
	modelicaParserT__82           = 83
	modelicaParserT__83           = 84
	modelicaParserT__84           = 85
	modelicaParserT__85           = 86
	modelicaParserT__86           = 87
	modelicaParserT__87           = 88
	modelicaParserIDENT           = 89
	modelicaParserSTRING          = 90
	modelicaParserUNSIGNED_NUMBER = 91
	modelicaParserWS              = 92
	modelicaParserCOMMENT         = 93
	modelicaParserLINE_COMMENT    = 94
)

// modelicaParser rules.
const (
	modelicaParserRULE_stored_definition                   = 0
	modelicaParserRULE_class_definition                    = 1
	modelicaParserRULE_class_specifier                     = 2
	modelicaParserRULE_class_prefixes                      = 3
	modelicaParserRULE_long_class_specifier                = 4
	modelicaParserRULE_short_class_specifier               = 5
	modelicaParserRULE_der_class_specifier                 = 6
	modelicaParserRULE_base_prefix                         = 7
	modelicaParserRULE_enum_list                           = 8
	modelicaParserRULE_enumeration_literal                 = 9
	modelicaParserRULE_composition                         = 10
	modelicaParserRULE_language_specification              = 11
	modelicaParserRULE_external_function_call              = 12
	modelicaParserRULE_element_list                        = 13
	modelicaParserRULE_element                             = 14
	modelicaParserRULE_import_clause                       = 15
	modelicaParserRULE_import_list                         = 16
	modelicaParserRULE_extends_clause                      = 17
	modelicaParserRULE_constraining_clause                 = 18
	modelicaParserRULE_component_clause                    = 19
	modelicaParserRULE_type_prefix                         = 20
	modelicaParserRULE_type_specifier                      = 21
	modelicaParserRULE_component_list                      = 22
	modelicaParserRULE_component_declaration               = 23
	modelicaParserRULE_condition_attribute                 = 24
	modelicaParserRULE_declaration                         = 25
	modelicaParserRULE_modification                        = 26
	modelicaParserRULE_class_modification                  = 27
	modelicaParserRULE_argument_list                       = 28
	modelicaParserRULE_argument                            = 29
	modelicaParserRULE_element_modification_or_replaceable = 30
	modelicaParserRULE_element_modification                = 31
	modelicaParserRULE_element_redeclaration               = 32
	modelicaParserRULE_element_replaceable                 = 33
	modelicaParserRULE_component_clause1                   = 34
	modelicaParserRULE_component_declaration1              = 35
	modelicaParserRULE_short_class_definition              = 36
	modelicaParserRULE_equation_section                    = 37
	modelicaParserRULE_algorithm_section                   = 38
	modelicaParserRULE_equation                            = 39
	modelicaParserRULE_statement                           = 40
	modelicaParserRULE_if_equation                         = 41
	modelicaParserRULE_if_statement                        = 42
	modelicaParserRULE_for_equation                        = 43
	modelicaParserRULE_for_statement                       = 44
	modelicaParserRULE_for_indices                         = 45
	modelicaParserRULE_for_index                           = 46
	modelicaParserRULE_while_statement                     = 47
	modelicaParserRULE_when_equation                       = 48
	modelicaParserRULE_when_statement                      = 49
	modelicaParserRULE_connect_clause                      = 50
	modelicaParserRULE_expression                          = 51
	modelicaParserRULE_simple_expression                   = 52
	modelicaParserRULE_logical_expression                  = 53
	modelicaParserRULE_logical_term                        = 54
	modelicaParserRULE_logical_factor                      = 55
	modelicaParserRULE_relation                            = 56
	modelicaParserRULE_rel_op                              = 57
	modelicaParserRULE_arithmetic_expression               = 58
	modelicaParserRULE_add_op                              = 59
	modelicaParserRULE_term                                = 60
	modelicaParserRULE_mul_op                              = 61
	modelicaParserRULE_factor                              = 62
	modelicaParserRULE_primary                             = 63
	modelicaParserRULE_name                                = 64
	modelicaParserRULE_component_reference                 = 65
	modelicaParserRULE_function_call_args                  = 66
	modelicaParserRULE_function_arguments                  = 67
	modelicaParserRULE_named_arguments                     = 68
	modelicaParserRULE_named_argument                      = 69
	modelicaParserRULE_function_argument                   = 70
	modelicaParserRULE_output_expression_list              = 71
	modelicaParserRULE_expression_list                     = 72
	modelicaParserRULE_array_subscripts                    = 73
	modelicaParserRULE_subscript_                          = 74
	modelicaParserRULE_comment                             = 75
	modelicaParserRULE_string_comment                      = 76
	modelicaParserRULE_annotation                          = 77
)

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

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

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

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

func NewEmptyStored_definitionContext() *Stored_definitionContext {
	var p = new(Stored_definitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_stored_definition
	return p
}

func (*Stored_definitionContext) IsStored_definitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_stored_definition

	return p
}

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

func (s *Stored_definitionContext) AllClass_definition() []IClass_definitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClass_definitionContext)(nil)).Elem())
	var tst = make([]IClass_definitionContext, len(ts))

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

	return tst
}

func (s *Stored_definitionContext) Class_definition(i int) IClass_definitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_definitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClass_definitionContext)
}

func (s *Stored_definitionContext) AllName() []INameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*INameContext)(nil)).Elem())
	var tst = make([]INameContext, len(ts))

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

	return tst
}

func (s *Stored_definitionContext) Name(i int) INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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

func (s *Stored_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterStored_definition(s)
	}
}

func (s *Stored_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitStored_definition(s)
	}
}

func (p *modelicaParser) Stored_definition() (localctx IStored_definitionContext) {
	this := p
	_ = this

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

	for _la == modelicaParserT__0 {
		{
			p.SetState(156)
			p.Match(modelicaParserT__0)
		}
		p.SetState(158)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__86 || _la == modelicaParserIDENT {
			{
				p.SetState(157)
				p.Name()
			}

		}
		{
			p.SetState(160)
			p.Match(modelicaParserT__1)
		}

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

	for ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<modelicaParserT__2)|(1<<modelicaParserT__3)|(1<<modelicaParserT__4)|(1<<modelicaParserT__5)|(1<<modelicaParserT__6)|(1<<modelicaParserT__7)|(1<<modelicaParserT__8)|(1<<modelicaParserT__9)|(1<<modelicaParserT__10)|(1<<modelicaParserT__11)|(1<<modelicaParserT__12)|(1<<modelicaParserT__13)|(1<<modelicaParserT__14)|(1<<modelicaParserT__15)|(1<<modelicaParserT__16))) != 0 {
		p.SetState(167)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__2 {
			{
				p.SetState(166)
				p.Match(modelicaParserT__2)
			}

		}
		{
			p.SetState(169)
			p.Class_definition()
		}
		{
			p.SetState(170)
			p.Match(modelicaParserT__1)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyClass_definitionContext() *Class_definitionContext {
	var p = new(Class_definitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_class_definition
	return p
}

func (*Class_definitionContext) IsClass_definitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_class_definition

	return p
}

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

func (s *Class_definitionContext) Class_prefixes() IClass_prefixesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_prefixesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_prefixesContext)
}

func (s *Class_definitionContext) Class_specifier() IClass_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_specifierContext)
}

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

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

func (s *Class_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterClass_definition(s)
	}
}

func (s *Class_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitClass_definition(s)
	}
}

func (p *modelicaParser) Class_definition() (localctx IClass_definitionContext) {
	this := p
	_ = this

	localctx = NewClass_definitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, modelicaParserRULE_class_definition)
	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(178)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__3 {
		{
			p.SetState(177)
			p.Match(modelicaParserT__3)
		}

	}
	{
		p.SetState(180)
		p.Class_prefixes()
	}
	{
		p.SetState(181)
		p.Class_specifier()
	}

	return localctx
}

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

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

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

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

func NewEmptyClass_specifierContext() *Class_specifierContext {
	var p = new(Class_specifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_class_specifier
	return p
}

func (*Class_specifierContext) IsClass_specifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_class_specifier

	return p
}

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

func (s *Class_specifierContext) Long_class_specifier() ILong_class_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILong_class_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILong_class_specifierContext)
}

func (s *Class_specifierContext) Short_class_specifier() IShort_class_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShort_class_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShort_class_specifierContext)
}

func (s *Class_specifierContext) Der_class_specifier() IDer_class_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDer_class_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDer_class_specifierContext)
}

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

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

func (s *Class_specifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterClass_specifier(s)
	}
}

func (s *Class_specifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitClass_specifier(s)
	}
}

func (p *modelicaParser) Class_specifier() (localctx IClass_specifierContext) {
	this := p
	_ = this

	localctx = NewClass_specifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, modelicaParserRULE_class_specifier)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(184)
			p.Short_class_specifier()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(185)
			p.Der_class_specifier()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyClass_prefixesContext() *Class_prefixesContext {
	var p = new(Class_prefixesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_class_prefixes
	return p
}

func (*Class_prefixesContext) IsClass_prefixesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_class_prefixes

	return p
}

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

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

func (s *Class_prefixesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterClass_prefixes(s)
	}
}

func (s *Class_prefixesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitClass_prefixes(s)
	}
}

func (p *modelicaParser) Class_prefixes() (localctx IClass_prefixesContext) {
	this := p
	_ = this

	localctx = NewClass_prefixesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, modelicaParserRULE_class_prefixes)
	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(189)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__4 {
		{
			p.SetState(188)
			p.Match(modelicaParserT__4)
		}

	}
	p.SetState(212)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(191)
			p.Match(modelicaParserT__5)
		}

	case 2:
		{
			p.SetState(192)
			p.Match(modelicaParserT__6)
		}

	case 3:
		p.SetState(194)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__7 {
			{
				p.SetState(193)
				p.Match(modelicaParserT__7)
			}

		}
		{
			p.SetState(196)
			p.Match(modelicaParserT__8)
		}

	case 4:
		{
			p.SetState(197)
			p.Match(modelicaParserT__9)
		}

	case 5:
		p.SetState(199)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__10 {
			{
				p.SetState(198)
				p.Match(modelicaParserT__10)
			}

		}
		{
			p.SetState(201)
			p.Match(modelicaParserT__11)
		}

	case 6:
		{
			p.SetState(202)
			p.Match(modelicaParserT__12)
		}

	case 7:
		{
			p.SetState(203)
			p.Match(modelicaParserT__13)
		}

	case 8:
		p.SetState(205)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__14 || _la == modelicaParserT__15 {
			{
				p.SetState(204)
				_la = p.GetTokenStream().LA(1)

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

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

		if _la == modelicaParserT__7 {
			{
				p.SetState(207)
				p.Match(modelicaParserT__7)
			}

		}
		{
			p.SetState(210)
			p.Match(modelicaParserT__16)
		}

	case 9:
		{
			p.SetState(211)
			p.Match(modelicaParserT__7)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyLong_class_specifierContext() *Long_class_specifierContext {
	var p = new(Long_class_specifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_long_class_specifier
	return p
}

func (*Long_class_specifierContext) IsLong_class_specifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_long_class_specifier

	return p
}

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

func (s *Long_class_specifierContext) AllIDENT() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserIDENT)
}

func (s *Long_class_specifierContext) IDENT(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, i)
}

func (s *Long_class_specifierContext) String_comment() IString_commentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IString_commentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IString_commentContext)
}

func (s *Long_class_specifierContext) Composition() ICompositionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompositionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompositionContext)
}

func (s *Long_class_specifierContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

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

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

func (s *Long_class_specifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterLong_class_specifier(s)
	}
}

func (s *Long_class_specifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitLong_class_specifier(s)
	}
}

func (p *modelicaParser) Long_class_specifier() (localctx ILong_class_specifierContext) {
	this := p
	_ = this

	localctx = NewLong_class_specifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, modelicaParserRULE_long_class_specifier)
	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(230)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserIDENT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(214)
			p.Match(modelicaParserIDENT)
		}
		{
			p.SetState(215)
			p.String_comment()
		}
		{
			p.SetState(216)
			p.Composition()
		}
		{
			p.SetState(217)
			p.Match(modelicaParserT__17)
		}
		{
			p.SetState(218)
			p.Match(modelicaParserIDENT)
		}

	case modelicaParserT__18:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(220)
			p.Match(modelicaParserT__18)
		}
		{
			p.SetState(221)
			p.Match(modelicaParserIDENT)
		}
		p.SetState(223)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__21 {
			{
				p.SetState(222)
				p.Class_modification()
			}

		}
		{
			p.SetState(225)
			p.String_comment()
		}
		{
			p.SetState(226)
			p.Composition()
		}
		{
			p.SetState(227)
			p.Match(modelicaParserT__17)
		}
		{
			p.SetState(228)
			p.Match(modelicaParserIDENT)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyShort_class_specifierContext() *Short_class_specifierContext {
	var p = new(Short_class_specifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_short_class_specifier
	return p
}

func (*Short_class_specifierContext) IsShort_class_specifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_short_class_specifier

	return p
}

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

func (s *Short_class_specifierContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

func (s *Short_class_specifierContext) Base_prefix() IBase_prefixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBase_prefixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBase_prefixContext)
}

func (s *Short_class_specifierContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Short_class_specifierContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

func (s *Short_class_specifierContext) Array_subscripts() IArray_subscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArray_subscriptsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArray_subscriptsContext)
}

func (s *Short_class_specifierContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

func (s *Short_class_specifierContext) Enum_list() IEnum_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnum_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnum_listContext)
}

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

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

func (s *Short_class_specifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterShort_class_specifier(s)
	}
}

func (s *Short_class_specifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitShort_class_specifier(s)
	}
}

func (p *modelicaParser) Short_class_specifier() (localctx IShort_class_specifierContext) {
	this := p
	_ = this

	localctx = NewShort_class_specifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, modelicaParserRULE_short_class_specifier)
	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(256)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(232)
			p.Match(modelicaParserIDENT)
		}
		{
			p.SetState(233)
			p.Match(modelicaParserT__19)
		}
		{
			p.SetState(234)
			p.Base_prefix()
		}
		{
			p.SetState(235)
			p.Name()
		}
		p.SetState(237)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__83 {
			{
				p.SetState(236)
				p.Array_subscripts()
			}

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

		if _la == modelicaParserT__21 {
			{
				p.SetState(239)
				p.Class_modification()
			}

		}
		{
			p.SetState(242)
			p.Comment()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(244)
			p.Match(modelicaParserIDENT)
		}
		{
			p.SetState(245)
			p.Match(modelicaParserT__19)
		}
		{
			p.SetState(246)
			p.Match(modelicaParserT__20)
		}
		{
			p.SetState(247)
			p.Match(modelicaParserT__21)
		}
		p.SetState(252)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__23, modelicaParserIDENT:
			p.SetState(249)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == modelicaParserIDENT {
				{
					p.SetState(248)
					p.Enum_list()
				}

			}

		case modelicaParserT__22:
			{
				p.SetState(251)
				p.Match(modelicaParserT__22)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(254)
			p.Match(modelicaParserT__23)
		}
		{
			p.SetState(255)
			p.Comment()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDer_class_specifierContext() *Der_class_specifierContext {
	var p = new(Der_class_specifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_der_class_specifier
	return p
}

func (*Der_class_specifierContext) IsDer_class_specifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_der_class_specifier

	return p
}

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

func (s *Der_class_specifierContext) AllIDENT() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserIDENT)
}

func (s *Der_class_specifierContext) IDENT(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, i)
}

func (s *Der_class_specifierContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Der_class_specifierContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

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

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

func (s *Der_class_specifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterDer_class_specifier(s)
	}
}

func (s *Der_class_specifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitDer_class_specifier(s)
	}
}

func (p *modelicaParser) Der_class_specifier() (localctx IDer_class_specifierContext) {
	this := p
	_ = this

	localctx = NewDer_class_specifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, modelicaParserRULE_der_class_specifier)
	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(258)
		p.Match(modelicaParserIDENT)
	}
	{
		p.SetState(259)
		p.Match(modelicaParserT__19)
	}
	{
		p.SetState(260)
		p.Match(modelicaParserT__24)
	}
	{
		p.SetState(261)
		p.Match(modelicaParserT__21)
	}
	{
		p.SetState(262)
		p.Name()
	}
	{
		p.SetState(263)
		p.Match(modelicaParserT__25)
	}
	{
		p.SetState(264)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(269)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(265)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(266)
			p.Match(modelicaParserIDENT)
		}

		p.SetState(271)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(272)
		p.Match(modelicaParserT__23)
	}
	{
		p.SetState(273)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyBase_prefixContext() *Base_prefixContext {
	var p = new(Base_prefixContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_base_prefix
	return p
}

func (*Base_prefixContext) IsBase_prefixContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_base_prefix

	return p
}

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

func (s *Base_prefixContext) Type_prefix() IType_prefixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_prefixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_prefixContext)
}

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

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

func (s *Base_prefixContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterBase_prefix(s)
	}
}

func (s *Base_prefixContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitBase_prefix(s)
	}
}

func (p *modelicaParser) Base_prefix() (localctx IBase_prefixContext) {
	this := p
	_ = this

	localctx = NewBase_prefixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, modelicaParserRULE_base_prefix)

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

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

	return localctx
}

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

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

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

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

func NewEmptyEnum_listContext() *Enum_listContext {
	var p = new(Enum_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_enum_list
	return p
}

func (*Enum_listContext) IsEnum_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_enum_list

	return p
}

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

func (s *Enum_listContext) AllEnumeration_literal() []IEnumeration_literalContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumeration_literalContext)(nil)).Elem())
	var tst = make([]IEnumeration_literalContext, len(ts))

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

	return tst
}

func (s *Enum_listContext) Enumeration_literal(i int) IEnumeration_literalContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumeration_literalContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumeration_literalContext)
}

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

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

func (s *Enum_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterEnum_list(s)
	}
}

func (s *Enum_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitEnum_list(s)
	}
}

func (p *modelicaParser) Enum_list() (localctx IEnum_listContext) {
	this := p
	_ = this

	localctx = NewEnum_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, modelicaParserRULE_enum_list)
	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(277)
		p.Enumeration_literal()
	}
	p.SetState(282)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(278)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(279)
			p.Enumeration_literal()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyEnumeration_literalContext() *Enumeration_literalContext {
	var p = new(Enumeration_literalContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_enumeration_literal
	return p
}

func (*Enumeration_literalContext) IsEnumeration_literalContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_enumeration_literal

	return p
}

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

func (s *Enumeration_literalContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

func (s *Enumeration_literalContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

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

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

func (s *Enumeration_literalContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterEnumeration_literal(s)
	}
}

func (s *Enumeration_literalContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitEnumeration_literal(s)
	}
}

func (p *modelicaParser) Enumeration_literal() (localctx IEnumeration_literalContext) {
	this := p
	_ = this

	localctx = NewEnumeration_literalContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, modelicaParserRULE_enumeration_literal)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(285)
		p.Match(modelicaParserIDENT)
	}
	{
		p.SetState(286)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyCompositionContext() *CompositionContext {
	var p = new(CompositionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_composition
	return p
}

func (*CompositionContext) IsCompositionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_composition

	return p
}

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

func (s *CompositionContext) AllElement_list() []IElement_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IElement_listContext)(nil)).Elem())
	var tst = make([]IElement_listContext, len(ts))

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

	return tst
}

func (s *CompositionContext) Element_list(i int) IElement_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElement_listContext)
}

func (s *CompositionContext) AllEquation_section() []IEquation_sectionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEquation_sectionContext)(nil)).Elem())
	var tst = make([]IEquation_sectionContext, len(ts))

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

	return tst
}

func (s *CompositionContext) Equation_section(i int) IEquation_sectionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEquation_sectionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEquation_sectionContext)
}

func (s *CompositionContext) AllAlgorithm_section() []IAlgorithm_sectionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAlgorithm_sectionContext)(nil)).Elem())
	var tst = make([]IAlgorithm_sectionContext, len(ts))

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

	return tst
}

func (s *CompositionContext) Algorithm_section(i int) IAlgorithm_sectionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlgorithm_sectionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAlgorithm_sectionContext)
}

func (s *CompositionContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

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

	return tst
}

func (s *CompositionContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *CompositionContext) Language_specification() ILanguage_specificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILanguage_specificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILanguage_specificationContext)
}

func (s *CompositionContext) External_function_call() IExternal_function_callContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExternal_function_callContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExternal_function_callContext)
}

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

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

func (s *CompositionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComposition(s)
	}
}

func (s *CompositionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComposition(s)
	}
}

func (p *modelicaParser) Composition() (localctx ICompositionContext) {
	this := p
	_ = this

	localctx = NewCompositionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, modelicaParserRULE_composition)
	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(288)
		p.Element_list()
	}
	p.SetState(297)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-27)&-(0x1f+1)) == 0 && ((1<<uint((_la-27)))&((1<<(modelicaParserT__26-27))|(1<<(modelicaParserT__27-27))|(1<<(modelicaParserT__48-27))|(1<<(modelicaParserT__49-27))|(1<<(modelicaParserT__50-27)))) != 0 {
		p.SetState(295)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 21, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(289)
				p.Match(modelicaParserT__26)
			}
			{
				p.SetState(290)
				p.Element_list()
			}

		case 2:
			{
				p.SetState(291)
				p.Match(modelicaParserT__27)
			}
			{
				p.SetState(292)
				p.Element_list()
			}

		case 3:
			{
				p.SetState(293)
				p.Equation_section()
			}

		case 4:
			{
				p.SetState(294)
				p.Algorithm_section()
			}

		}

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

	if _la == modelicaParserT__28 {
		{
			p.SetState(300)
			p.Match(modelicaParserT__28)
		}
		p.SetState(302)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserSTRING {
			{
				p.SetState(301)
				p.Language_specification()
			}

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

		if _la == modelicaParserT__86 || _la == modelicaParserIDENT {
			{
				p.SetState(304)
				p.External_function_call()
			}

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

		if _la == modelicaParserT__87 {
			{
				p.SetState(307)
				p.Annotation()
			}

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

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

	if _la == modelicaParserT__87 {
		{
			p.SetState(313)
			p.Annotation()
		}
		{
			p.SetState(314)
			p.Match(modelicaParserT__1)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyLanguage_specificationContext() *Language_specificationContext {
	var p = new(Language_specificationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_language_specification
	return p
}

func (*Language_specificationContext) IsLanguage_specificationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_language_specification

	return p
}

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

func (s *Language_specificationContext) STRING() antlr.TerminalNode {
	return s.GetToken(modelicaParserSTRING, 0)
}

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

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

func (s *Language_specificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterLanguage_specification(s)
	}
}

func (s *Language_specificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitLanguage_specification(s)
	}
}

func (p *modelicaParser) Language_specification() (localctx ILanguage_specificationContext) {
	this := p
	_ = this

	localctx = NewLanguage_specificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, modelicaParserRULE_language_specification)

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

	defer func() {
		if err := recover(); err != nil {
			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(318)
		p.Match(modelicaParserSTRING)
	}

	return localctx
}

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

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

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

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

func NewEmptyExternal_function_callContext() *External_function_callContext {
	var p = new(External_function_callContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_external_function_call
	return p
}

func (*External_function_callContext) IsExternal_function_callContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_external_function_call

	return p
}

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

func (s *External_function_callContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

func (s *External_function_callContext) Component_reference() IComponent_referenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_referenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_referenceContext)
}

func (s *External_function_callContext) Expression_list() IExpression_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpression_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpression_listContext)
}

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

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

func (s *External_function_callContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterExternal_function_call(s)
	}
}

func (s *External_function_callContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitExternal_function_call(s)
	}
}

func (p *modelicaParser) External_function_call() (localctx IExternal_function_callContext) {
	this := p
	_ = this

	localctx = NewExternal_function_callContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, modelicaParserRULE_external_function_call)
	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(323)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(320)
			p.Component_reference()
		}
		{
			p.SetState(321)
			p.Match(modelicaParserT__19)
		}

	}
	{
		p.SetState(325)
		p.Match(modelicaParserIDENT)
	}
	{
		p.SetState(326)
		p.Match(modelicaParserT__21)
	}
	p.SetState(328)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-18)&-(0x1f+1)) == 0 && ((1<<uint((_la-18)))&((1<<(modelicaParserT__17-18))|(1<<(modelicaParserT__21-18))|(1<<(modelicaParserT__24-18))|(1<<(modelicaParserT__45-18))|(1<<(modelicaParserT__48-18)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(modelicaParserT__65-66))|(1<<(modelicaParserT__72-66))|(1<<(modelicaParserT__73-66))|(1<<(modelicaParserT__74-66))|(1<<(modelicaParserT__75-66))|(1<<(modelicaParserT__81-66))|(1<<(modelicaParserT__82-66))|(1<<(modelicaParserT__83-66))|(1<<(modelicaParserT__85-66))|(1<<(modelicaParserT__86-66))|(1<<(modelicaParserIDENT-66))|(1<<(modelicaParserSTRING-66))|(1<<(modelicaParserUNSIGNED_NUMBER-66)))) != 0) {
		{
			p.SetState(327)
			p.Expression_list()
		}

	}
	{
		p.SetState(330)
		p.Match(modelicaParserT__23)
	}

	return localctx
}

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

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

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

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

func NewEmptyElement_listContext() *Element_listContext {
	var p = new(Element_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element_list
	return p
}

func (*Element_listContext) IsElement_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element_list

	return p
}

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

func (s *Element_listContext) AllElement() []IElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IElementContext)(nil)).Elem())
	var tst = make([]IElementContext, len(ts))

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

	return tst
}

func (s *Element_listContext) Element(i int) IElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElementContext)
}

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

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

func (s *Element_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement_list(s)
	}
}

func (s *Element_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement_list(s)
	}
}

func (p *modelicaParser) Element_list() (localctx IElement_listContext) {
	this := p
	_ = this

	localctx = NewElement_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, modelicaParserRULE_element_list)
	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(337)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<modelicaParserT__2)|(1<<modelicaParserT__3)|(1<<modelicaParserT__4)|(1<<modelicaParserT__5)|(1<<modelicaParserT__6)|(1<<modelicaParserT__7)|(1<<modelicaParserT__8)|(1<<modelicaParserT__9)|(1<<modelicaParserT__10)|(1<<modelicaParserT__11)|(1<<modelicaParserT__12)|(1<<modelicaParserT__13)|(1<<modelicaParserT__14)|(1<<modelicaParserT__15)|(1<<modelicaParserT__16)|(1<<modelicaParserT__18)|(1<<modelicaParserT__29)|(1<<modelicaParserT__30))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(modelicaParserT__31-32))|(1<<(modelicaParserT__32-32))|(1<<(modelicaParserT__33-32))|(1<<(modelicaParserT__38-32))|(1<<(modelicaParserT__39-32))|(1<<(modelicaParserT__40-32))|(1<<(modelicaParserT__41-32))|(1<<(modelicaParserT__42-32))|(1<<(modelicaParserT__43-32))|(1<<(modelicaParserT__44-32)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(332)
			p.Element()
		}
		{
			p.SetState(333)
			p.Match(modelicaParserT__1)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyElementContext() *ElementContext {
	var p = new(ElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element
	return p
}

func (*ElementContext) IsElementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element

	return p
}

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

func (s *ElementContext) Import_clause() IImport_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImport_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImport_clauseContext)
}

func (s *ElementContext) Extends_clause() IExtends_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExtends_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExtends_clauseContext)
}

func (s *ElementContext) Class_definition() IClass_definitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_definitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_definitionContext)
}

func (s *ElementContext) Component_clause() IComponent_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_clauseContext)
}

func (s *ElementContext) Constraining_clause() IConstraining_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstraining_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstraining_clauseContext)
}

func (s *ElementContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

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

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

func (s *ElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement(s)
	}
}

func (s *ElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement(s)
	}
}

func (p *modelicaParser) Element() (localctx IElementContext) {
	this := p
	_ = this

	localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, modelicaParserRULE_element)
	var _la int

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

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

	p.SetState(370)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__33:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(340)
			p.Import_clause()
		}

	case modelicaParserT__18:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(341)
			p.Extends_clause()
		}

	case modelicaParserT__2, modelicaParserT__3, modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16, modelicaParserT__29, modelicaParserT__30, modelicaParserT__31, modelicaParserT__32, modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(343)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__29 {
			{
				p.SetState(342)
				p.Match(modelicaParserT__29)
			}

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

		if _la == modelicaParserT__2 {
			{
				p.SetState(345)
				p.Match(modelicaParserT__2)
			}

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

		if _la == modelicaParserT__30 {
			{
				p.SetState(348)
				p.Match(modelicaParserT__30)
			}

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

		if _la == modelicaParserT__31 {
			{
				p.SetState(351)
				p.Match(modelicaParserT__31)
			}

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

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__3, modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16, modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
			p.SetState(356)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case modelicaParserT__3, modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16:
				{
					p.SetState(354)
					p.Class_definition()
				}

			case modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
				{
					p.SetState(355)
					p.Component_clause()
				}

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

		case modelicaParserT__32:
			{
				p.SetState(358)
				p.Match(modelicaParserT__32)
			}
			p.SetState(361)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case modelicaParserT__3, modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16:
				{
					p.SetState(359)
					p.Class_definition()
				}

			case modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
				{
					p.SetState(360)
					p.Component_clause()
				}

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

			if _la == modelicaParserT__37 {
				{
					p.SetState(363)
					p.Constraining_clause()
				}
				{
					p.SetState(364)
					p.Comment()
				}

			}

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

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

	return localctx
}

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

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

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

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

func NewEmptyImport_clauseContext() *Import_clauseContext {
	var p = new(Import_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_import_clause
	return p
}

func (*Import_clauseContext) IsImport_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_import_clause

	return p
}

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

func (s *Import_clauseContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

func (s *Import_clauseContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

func (s *Import_clauseContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Import_clauseContext) Import_list() IImport_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImport_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImport_listContext)
}

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

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

func (s *Import_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterImport_clause(s)
	}
}

func (s *Import_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitImport_clause(s)
	}
}

func (p *modelicaParser) Import_clause() (localctx IImport_clauseContext) {
	this := p
	_ = this

	localctx = NewImport_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, modelicaParserRULE_import_clause)

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

	defer func() {
		if err := recover(); err != nil {
			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(372)
		p.Match(modelicaParserT__33)
	}
	p.SetState(385)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(373)
			p.Match(modelicaParserIDENT)
		}
		{
			p.SetState(374)
			p.Match(modelicaParserT__19)
		}
		{
			p.SetState(375)
			p.Name()
		}

	case 2:
		{
			p.SetState(376)
			p.Name()
		}
		{
			p.SetState(377)
			p.Match(modelicaParserT__34)
		}

	case 3:
		{
			p.SetState(379)
			p.Name()
		}
		{
			p.SetState(380)
			p.Match(modelicaParserT__35)
		}
		{
			p.SetState(381)
			p.Import_list()
		}
		{
			p.SetState(382)
			p.Match(modelicaParserT__36)
		}

	case 4:
		{
			p.SetState(384)
			p.Name()
		}

	}
	{
		p.SetState(387)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyImport_listContext() *Import_listContext {
	var p = new(Import_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_import_list
	return p
}

func (*Import_listContext) IsImport_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_import_list

	return p
}

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

func (s *Import_listContext) AllIDENT() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserIDENT)
}

func (s *Import_listContext) IDENT(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, i)
}

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

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

func (s *Import_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterImport_list(s)
	}
}

func (s *Import_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitImport_list(s)
	}
}

func (p *modelicaParser) Import_list() (localctx IImport_listContext) {
	this := p
	_ = this

	localctx = NewImport_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, modelicaParserRULE_import_list)
	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(389)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(394)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(390)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(391)
			p.Match(modelicaParserIDENT)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyExtends_clauseContext() *Extends_clauseContext {
	var p = new(Extends_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_extends_clause
	return p
}

func (*Extends_clauseContext) IsExtends_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_extends_clause

	return p
}

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

func (s *Extends_clauseContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Extends_clauseContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

func (s *Extends_clauseContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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

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

func (s *Extends_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterExtends_clause(s)
	}
}

func (s *Extends_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitExtends_clause(s)
	}
}

func (p *modelicaParser) Extends_clause() (localctx IExtends_clauseContext) {
	this := p
	_ = this

	localctx = NewExtends_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, modelicaParserRULE_extends_clause)
	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(397)
		p.Match(modelicaParserT__18)
	}
	{
		p.SetState(398)
		p.Name()
	}
	p.SetState(400)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__21 {
		{
			p.SetState(399)
			p.Class_modification()
		}

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

	if _la == modelicaParserT__87 {
		{
			p.SetState(402)
			p.Annotation()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyConstraining_clauseContext() *Constraining_clauseContext {
	var p = new(Constraining_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_constraining_clause
	return p
}

func (*Constraining_clauseContext) IsConstraining_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_constraining_clause

	return p
}

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

func (s *Constraining_clauseContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Constraining_clauseContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

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

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

func (s *Constraining_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterConstraining_clause(s)
	}
}

func (s *Constraining_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitConstraining_clause(s)
	}
}

func (p *modelicaParser) Constraining_clause() (localctx IConstraining_clauseContext) {
	this := p
	_ = this

	localctx = NewConstraining_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, modelicaParserRULE_constraining_clause)
	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.Match(modelicaParserT__37)
	}
	{
		p.SetState(406)
		p.Name()
	}
	p.SetState(408)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__21 {
		{
			p.SetState(407)
			p.Class_modification()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyComponent_clauseContext() *Component_clauseContext {
	var p = new(Component_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_clause
	return p
}

func (*Component_clauseContext) IsComponent_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_clause

	return p
}

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

func (s *Component_clauseContext) Type_prefix() IType_prefixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_prefixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_prefixContext)
}

func (s *Component_clauseContext) Type_specifier() IType_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_specifierContext)
}

func (s *Component_clauseContext) Component_list() IComponent_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_listContext)
}

func (s *Component_clauseContext) Array_subscripts() IArray_subscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArray_subscriptsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArray_subscriptsContext)
}

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

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

func (s *Component_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_clause(s)
	}
}

func (s *Component_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_clause(s)
	}
}

func (p *modelicaParser) Component_clause() (localctx IComponent_clauseContext) {
	this := p
	_ = this

	localctx = NewComponent_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, modelicaParserRULE_component_clause)
	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(410)
		p.Type_prefix()
	}
	{
		p.SetState(411)
		p.Type_specifier()
	}
	p.SetState(413)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__83 {
		{
			p.SetState(412)
			p.Array_subscripts()
		}

	}
	{
		p.SetState(415)
		p.Component_list()
	}

	return localctx
}

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

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

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

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

func NewEmptyType_prefixContext() *Type_prefixContext {
	var p = new(Type_prefixContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_type_prefix
	return p
}

func (*Type_prefixContext) IsType_prefixContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_type_prefix

	return p
}

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

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

func (s *Type_prefixContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterType_prefix(s)
	}
}

func (s *Type_prefixContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitType_prefix(s)
	}
}

func (p *modelicaParser) Type_prefix() (localctx IType_prefixContext) {
	this := p
	_ = this

	localctx = NewType_prefixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, modelicaParserRULE_type_prefix)
	var _la int

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

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

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

	if _la == modelicaParserT__38 || _la == modelicaParserT__39 {
		{
			p.SetState(417)
			_la = p.GetTokenStream().LA(1)

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

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

	if ((_la-41)&-(0x1f+1)) == 0 && ((1<<uint((_la-41)))&((1<<(modelicaParserT__40-41))|(1<<(modelicaParserT__41-41))|(1<<(modelicaParserT__42-41)))) != 0 {
		{
			p.SetState(420)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-41)&-(0x1f+1)) == 0 && ((1<<uint((_la-41)))&((1<<(modelicaParserT__40-41))|(1<<(modelicaParserT__41-41))|(1<<(modelicaParserT__42-41)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

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

	if _la == modelicaParserT__43 || _la == modelicaParserT__44 {
		{
			p.SetState(423)
			_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyType_specifierContext() *Type_specifierContext {
	var p = new(Type_specifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_type_specifier
	return p
}

func (*Type_specifierContext) IsType_specifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_type_specifier

	return p
}

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

func (s *Type_specifierContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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

func (s *Type_specifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterType_specifier(s)
	}
}

func (s *Type_specifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitType_specifier(s)
	}
}

func (p *modelicaParser) Type_specifier() (localctx IType_specifierContext) {
	this := p
	_ = this

	localctx = NewType_specifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, modelicaParserRULE_type_specifier)

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

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

	return localctx
}

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

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

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

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

func NewEmptyComponent_listContext() *Component_listContext {
	var p = new(Component_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_list
	return p
}

func (*Component_listContext) IsComponent_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_list

	return p
}

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

func (s *Component_listContext) AllComponent_declaration() []IComponent_declarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IComponent_declarationContext)(nil)).Elem())
	var tst = make([]IComponent_declarationContext, len(ts))

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

	return tst
}

func (s *Component_listContext) Component_declaration(i int) IComponent_declarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_declarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IComponent_declarationContext)
}

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

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

func (s *Component_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_list(s)
	}
}

func (s *Component_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_list(s)
	}
}

func (p *modelicaParser) Component_list() (localctx IComponent_listContext) {
	this := p
	_ = this

	localctx = NewComponent_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, modelicaParserRULE_component_list)
	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(428)
		p.Component_declaration()
	}
	p.SetState(433)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(429)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(430)
			p.Component_declaration()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyComponent_declarationContext() *Component_declarationContext {
	var p = new(Component_declarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_declaration
	return p
}

func (*Component_declarationContext) IsComponent_declarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_declaration

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *Component_declarationContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

func (s *Component_declarationContext) Condition_attribute() ICondition_attributeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICondition_attributeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICondition_attributeContext)
}

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

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

func (s *Component_declarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_declaration(s)
	}
}

func (s *Component_declarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_declaration(s)
	}
}

func (p *modelicaParser) Component_declaration() (localctx IComponent_declarationContext) {
	this := p
	_ = this

	localctx = NewComponent_declarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, modelicaParserRULE_component_declaration)
	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(436)
		p.Declaration()
	}
	p.SetState(438)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__45 {
		{
			p.SetState(437)
			p.Condition_attribute()
		}

	}
	{
		p.SetState(440)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyCondition_attributeContext() *Condition_attributeContext {
	var p = new(Condition_attributeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_condition_attribute
	return p
}

func (*Condition_attributeContext) IsCondition_attributeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_condition_attribute

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *Condition_attributeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterCondition_attribute(s)
	}
}

func (s *Condition_attributeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitCondition_attribute(s)
	}
}

func (p *modelicaParser) Condition_attribute() (localctx ICondition_attributeContext) {
	this := p
	_ = this

	localctx = NewCondition_attributeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, modelicaParserRULE_condition_attribute)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(442)
		p.Match(modelicaParserT__45)
	}
	{
		p.SetState(443)
		p.Expression()
	}

	return localctx
}

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

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

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

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

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

func (*DeclarationContext) IsDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_declaration

	return p
}

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

func (s *DeclarationContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IArray_subscriptsContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IModificationContext)
}

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

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

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

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

func (p *modelicaParser) Declaration() (localctx IDeclarationContext) {
	this := p
	_ = this

	localctx = NewDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, modelicaParserRULE_declaration)
	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(445)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(447)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__83 {
		{
			p.SetState(446)
			p.Array_subscripts()
		}

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

	if ((_la-20)&-(0x1f+1)) == 0 && ((1<<uint((_la-20)))&((1<<(modelicaParserT__19-20))|(1<<(modelicaParserT__21-20))|(1<<(modelicaParserT__46-20)))) != 0 {
		{
			p.SetState(449)
			p.Modification()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyModificationContext() *ModificationContext {
	var p = new(ModificationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_modification
	return p
}

func (*ModificationContext) IsModificationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_modification

	return p
}

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

func (s *ModificationContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ModificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterModification(s)
	}
}

func (s *ModificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitModification(s)
	}
}

func (p *modelicaParser) Modification() (localctx IModificationContext) {
	this := p
	_ = this

	localctx = NewModificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, modelicaParserRULE_modification)
	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(461)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__21:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(452)
			p.Class_modification()
		}
		p.SetState(455)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__19 {
			{
				p.SetState(453)
				p.Match(modelicaParserT__19)
			}
			{
				p.SetState(454)
				p.Expression()
			}

		}

	case modelicaParserT__19:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(457)
			p.Match(modelicaParserT__19)
		}
		{
			p.SetState(458)
			p.Expression()
		}

	case modelicaParserT__46:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(459)
			p.Match(modelicaParserT__46)
		}
		{
			p.SetState(460)
			p.Expression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyClass_modificationContext() *Class_modificationContext {
	var p = new(Class_modificationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_class_modification
	return p
}

func (*Class_modificationContext) IsClass_modificationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_class_modification

	return p
}

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

func (s *Class_modificationContext) Argument_list() IArgument_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgument_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgument_listContext)
}

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

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

func (s *Class_modificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterClass_modification(s)
	}
}

func (s *Class_modificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitClass_modification(s)
	}
}

func (p *modelicaParser) Class_modification() (localctx IClass_modificationContext) {
	this := p
	_ = this

	localctx = NewClass_modificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, modelicaParserRULE_class_modification)
	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(463)
		p.Match(modelicaParserT__21)
	}
	p.SetState(465)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__2 || _la == modelicaParserT__29 || _la == modelicaParserT__32 || _la == modelicaParserT__47 || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(464)
			p.Argument_list()
		}

	}
	{
		p.SetState(467)
		p.Match(modelicaParserT__23)
	}

	return localctx
}

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

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

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

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

func NewEmptyArgument_listContext() *Argument_listContext {
	var p = new(Argument_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_argument_list
	return p
}

func (*Argument_listContext) IsArgument_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_argument_list

	return p
}

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

func (s *Argument_listContext) AllArgument() []IArgumentContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArgumentContext)(nil)).Elem())
	var tst = make([]IArgumentContext, len(ts))

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

	return tst
}

func (s *Argument_listContext) Argument(i int) IArgumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArgumentContext)
}

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

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

func (s *Argument_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterArgument_list(s)
	}
}

func (s *Argument_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitArgument_list(s)
	}
}

func (p *modelicaParser) Argument_list() (localctx IArgument_listContext) {
	this := p
	_ = this

	localctx = NewArgument_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, modelicaParserRULE_argument_list)
	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(469)
		p.Argument()
	}
	p.SetState(474)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(470)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(471)
			p.Argument()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyArgumentContext() *ArgumentContext {
	var p = new(ArgumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_argument
	return p
}

func (*ArgumentContext) IsArgumentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_argument

	return p
}

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

func (s *ArgumentContext) Element_modification_or_replaceable() IElement_modification_or_replaceableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_modification_or_replaceableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElement_modification_or_replaceableContext)
}

func (s *ArgumentContext) Element_redeclaration() IElement_redeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_redeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElement_redeclarationContext)
}

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

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

func (s *ArgumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterArgument(s)
	}
}

func (s *ArgumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitArgument(s)
	}
}

func (p *modelicaParser) Argument() (localctx IArgumentContext) {
	this := p
	_ = this

	localctx = NewArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, modelicaParserRULE_argument)

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

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

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__2, modelicaParserT__32, modelicaParserT__47, modelicaParserT__86, modelicaParserIDENT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(477)
			p.Element_modification_or_replaceable()
		}

	case modelicaParserT__29:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(478)
			p.Element_redeclaration()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyElement_modification_or_replaceableContext() *Element_modification_or_replaceableContext {
	var p = new(Element_modification_or_replaceableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element_modification_or_replaceable
	return p
}

func (*Element_modification_or_replaceableContext) IsElement_modification_or_replaceableContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element_modification_or_replaceable

	return p
}

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

func (s *Element_modification_or_replaceableContext) Element_modification() IElement_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElement_modificationContext)
}

func (s *Element_modification_or_replaceableContext) Element_replaceable() IElement_replaceableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_replaceableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElement_replaceableContext)
}

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

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

func (s *Element_modification_or_replaceableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement_modification_or_replaceable(s)
	}
}

func (s *Element_modification_or_replaceableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement_modification_or_replaceable(s)
	}
}

func (p *modelicaParser) Element_modification_or_replaceable() (localctx IElement_modification_or_replaceableContext) {
	this := p
	_ = this

	localctx = NewElement_modification_or_replaceableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, modelicaParserRULE_element_modification_or_replaceable)
	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(482)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__47 {
		{
			p.SetState(481)
			p.Match(modelicaParserT__47)
		}

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

	if _la == modelicaParserT__2 {
		{
			p.SetState(484)
			p.Match(modelicaParserT__2)
		}

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

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__86, modelicaParserIDENT:
		{
			p.SetState(487)
			p.Element_modification()
		}

	case modelicaParserT__32:
		{
			p.SetState(488)
			p.Element_replaceable()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyElement_modificationContext() *Element_modificationContext {
	var p = new(Element_modificationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element_modification
	return p
}

func (*Element_modificationContext) IsElement_modificationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element_modification

	return p
}

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

func (s *Element_modificationContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Element_modificationContext) String_comment() IString_commentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IString_commentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IString_commentContext)
}

func (s *Element_modificationContext) Modification() IModificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModificationContext)
}

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

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

func (s *Element_modificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement_modification(s)
	}
}

func (s *Element_modificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement_modification(s)
	}
}

func (p *modelicaParser) Element_modification() (localctx IElement_modificationContext) {
	this := p
	_ = this

	localctx = NewElement_modificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, modelicaParserRULE_element_modification)
	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(491)
		p.Name()
	}
	p.SetState(493)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-20)&-(0x1f+1)) == 0 && ((1<<uint((_la-20)))&((1<<(modelicaParserT__19-20))|(1<<(modelicaParserT__21-20))|(1<<(modelicaParserT__46-20)))) != 0 {
		{
			p.SetState(492)
			p.Modification()
		}

	}
	{
		p.SetState(495)
		p.String_comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyElement_redeclarationContext() *Element_redeclarationContext {
	var p = new(Element_redeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element_redeclaration
	return p
}

func (*Element_redeclarationContext) IsElement_redeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element_redeclaration

	return p
}

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

func (s *Element_redeclarationContext) Element_replaceable() IElement_replaceableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElement_replaceableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElement_replaceableContext)
}

func (s *Element_redeclarationContext) Short_class_definition() IShort_class_definitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShort_class_definitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShort_class_definitionContext)
}

func (s *Element_redeclarationContext) Component_clause1() IComponent_clause1Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_clause1Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_clause1Context)
}

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

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

func (s *Element_redeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement_redeclaration(s)
	}
}

func (s *Element_redeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement_redeclaration(s)
	}
}

func (p *modelicaParser) Element_redeclaration() (localctx IElement_redeclarationContext) {
	this := p
	_ = this

	localctx = NewElement_redeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, modelicaParserRULE_element_redeclaration)
	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(497)
		p.Match(modelicaParserT__29)
	}
	p.SetState(499)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__47 {
		{
			p.SetState(498)
			p.Match(modelicaParserT__47)
		}

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

	if _la == modelicaParserT__2 {
		{
			p.SetState(501)
			p.Match(modelicaParserT__2)
		}

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

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16, modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
		p.SetState(506)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16:
			{
				p.SetState(504)
				p.Short_class_definition()
			}

		case modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
			{
				p.SetState(505)
				p.Component_clause1()
			}

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

	case modelicaParserT__32:
		{
			p.SetState(508)
			p.Element_replaceable()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyElement_replaceableContext() *Element_replaceableContext {
	var p = new(Element_replaceableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_element_replaceable
	return p
}

func (*Element_replaceableContext) IsElement_replaceableContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_element_replaceable

	return p
}

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

func (s *Element_replaceableContext) Short_class_definition() IShort_class_definitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShort_class_definitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShort_class_definitionContext)
}

func (s *Element_replaceableContext) Component_clause1() IComponent_clause1Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_clause1Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_clause1Context)
}

func (s *Element_replaceableContext) Constraining_clause() IConstraining_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstraining_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstraining_clauseContext)
}

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

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

func (s *Element_replaceableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterElement_replaceable(s)
	}
}

func (s *Element_replaceableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitElement_replaceable(s)
	}
}

func (p *modelicaParser) Element_replaceable() (localctx IElement_replaceableContext) {
	this := p
	_ = this

	localctx = NewElement_replaceableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, modelicaParserRULE_element_replaceable)
	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(511)
		p.Match(modelicaParserT__32)
	}
	p.SetState(514)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__4, modelicaParserT__5, modelicaParserT__6, modelicaParserT__7, modelicaParserT__8, modelicaParserT__9, modelicaParserT__10, modelicaParserT__11, modelicaParserT__12, modelicaParserT__13, modelicaParserT__14, modelicaParserT__15, modelicaParserT__16:
		{
			p.SetState(512)
			p.Short_class_definition()
		}

	case modelicaParserT__38, modelicaParserT__39, modelicaParserT__40, modelicaParserT__41, modelicaParserT__42, modelicaParserT__43, modelicaParserT__44, modelicaParserT__86, modelicaParserIDENT:
		{
			p.SetState(513)
			p.Component_clause1()
		}

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

	if _la == modelicaParserT__37 {
		{
			p.SetState(516)
			p.Constraining_clause()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyComponent_clause1Context() *Component_clause1Context {
	var p = new(Component_clause1Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_clause1
	return p
}

func (*Component_clause1Context) IsComponent_clause1Context() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_clause1

	return p
}

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

func (s *Component_clause1Context) Type_prefix() IType_prefixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_prefixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_prefixContext)
}

func (s *Component_clause1Context) Type_specifier() IType_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_specifierContext)
}

func (s *Component_clause1Context) Component_declaration1() IComponent_declaration1Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_declaration1Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_declaration1Context)
}

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

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

func (s *Component_clause1Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_clause1(s)
	}
}

func (s *Component_clause1Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_clause1(s)
	}
}

func (p *modelicaParser) Component_clause1() (localctx IComponent_clause1Context) {
	this := p
	_ = this

	localctx = NewComponent_clause1Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, modelicaParserRULE_component_clause1)

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

	defer func() {
		if err := recover(); err != nil {
			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(519)
		p.Type_prefix()
	}
	{
		p.SetState(520)
		p.Type_specifier()
	}
	{
		p.SetState(521)
		p.Component_declaration1()
	}

	return localctx
}

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

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

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

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

func NewEmptyComponent_declaration1Context() *Component_declaration1Context {
	var p = new(Component_declaration1Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_declaration1
	return p
}

func (*Component_declaration1Context) IsComponent_declaration1Context() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_declaration1

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *Component_declaration1Context) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

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

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

func (s *Component_declaration1Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_declaration1(s)
	}
}

func (s *Component_declaration1Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_declaration1(s)
	}
}

func (p *modelicaParser) Component_declaration1() (localctx IComponent_declaration1Context) {
	this := p
	_ = this

	localctx = NewComponent_declaration1Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, modelicaParserRULE_component_declaration1)

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

	defer func() {
		if err := recover(); err != nil {
			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(523)
		p.Declaration()
	}
	{
		p.SetState(524)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyShort_class_definitionContext() *Short_class_definitionContext {
	var p = new(Short_class_definitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_short_class_definition
	return p
}

func (*Short_class_definitionContext) IsShort_class_definitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_short_class_definition

	return p
}

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

func (s *Short_class_definitionContext) Class_prefixes() IClass_prefixesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_prefixesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_prefixesContext)
}

func (s *Short_class_definitionContext) Short_class_specifier() IShort_class_specifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShort_class_specifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShort_class_specifierContext)
}

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

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

func (s *Short_class_definitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterShort_class_definition(s)
	}
}

func (s *Short_class_definitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitShort_class_definition(s)
	}
}

func (p *modelicaParser) Short_class_definition() (localctx IShort_class_definitionContext) {
	this := p
	_ = this

	localctx = NewShort_class_definitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, modelicaParserRULE_short_class_definition)

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

	defer func() {
		if err := recover(); err != nil {
			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)
		p.Class_prefixes()
	}
	{
		p.SetState(527)
		p.Short_class_specifier()
	}

	return localctx
}

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

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

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

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

func NewEmptyEquation_sectionContext() *Equation_sectionContext {
	var p = new(Equation_sectionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_equation_section
	return p
}

func (*Equation_sectionContext) IsEquation_sectionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_equation_section

	return p
}

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

func (s *Equation_sectionContext) AllEquation() []IEquationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEquationContext)(nil)).Elem())
	var tst = make([]IEquationContext, len(ts))

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

	return tst
}

func (s *Equation_sectionContext) Equation(i int) IEquationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEquationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEquationContext)
}

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

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

func (s *Equation_sectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterEquation_section(s)
	}
}

func (s *Equation_sectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitEquation_section(s)
	}
}

func (p *modelicaParser) Equation_section() (localctx IEquation_sectionContext) {
	this := p
	_ = this

	localctx = NewEquation_sectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, modelicaParserRULE_equation_section)
	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(530)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__48 {
		{
			p.SetState(529)
			p.Match(modelicaParserT__48)
		}

	}
	{
		p.SetState(532)
		p.Match(modelicaParserT__49)
	}
	p.SetState(538)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(533)
				p.Equation()
			}
			{
				p.SetState(534)
				p.Match(modelicaParserT__1)
			}

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

	return localctx
}

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

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

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

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

func NewEmptyAlgorithm_sectionContext() *Algorithm_sectionContext {
	var p = new(Algorithm_sectionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_algorithm_section
	return p
}

func (*Algorithm_sectionContext) IsAlgorithm_sectionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_algorithm_section

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *Algorithm_sectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterAlgorithm_section(s)
	}
}

func (s *Algorithm_sectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitAlgorithm_section(s)
	}
}

func (p *modelicaParser) Algorithm_section() (localctx IAlgorithm_sectionContext) {
	this := p
	_ = this

	localctx = NewAlgorithm_sectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, modelicaParserRULE_algorithm_section)
	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(542)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__48 {
		{
			p.SetState(541)
			p.Match(modelicaParserT__48)
		}

	}
	{
		p.SetState(544)
		p.Match(modelicaParserT__50)
	}
	p.SetState(550)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(545)
			p.Statement()
		}
		{
			p.SetState(546)
			p.Match(modelicaParserT__1)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyEquationContext() *EquationContext {
	var p = new(EquationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_equation
	return p
}

func (*EquationContext) IsEquationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_equation

	return p
}

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

func (s *EquationContext) Comment() ICommentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

func (s *EquationContext) Simple_expression() ISimple_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimple_expressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimple_expressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *EquationContext) If_equation() IIf_equationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIf_equationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIf_equationContext)
}

func (s *EquationContext) For_equation() IFor_equationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFor_equationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFor_equationContext)
}

func (s *EquationContext) Connect_clause() IConnect_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConnect_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConnect_clauseContext)
}

func (s *EquationContext) When_equation() IWhen_equationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhen_equationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhen_equationContext)
}

func (s *EquationContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *EquationContext) Function_call_args() IFunction_call_argsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_call_argsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_call_argsContext)
}

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

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

func (s *EquationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterEquation(s)
	}
}

func (s *EquationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitEquation(s)
	}
}

func (p *modelicaParser) Equation() (localctx IEquationContext) {
	this := p
	_ = this

	localctx = NewEquationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, modelicaParserRULE_equation)

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

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

	p.EnterOuterAlt(localctx, 1)
	p.SetState(564)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(553)
			p.Simple_expression()
		}
		{
			p.SetState(554)
			p.Match(modelicaParserT__19)
		}
		{
			p.SetState(555)
			p.Expression()
		}

	case 2:
		{
			p.SetState(557)
			p.If_equation()
		}

	case 3:
		{
			p.SetState(558)
			p.For_equation()
		}

	case 4:
		{
			p.SetState(559)
			p.Connect_clause()
		}

	case 5:
		{
			p.SetState(560)
			p.When_equation()
		}

	case 6:
		{
			p.SetState(561)
			p.Name()
		}
		{
			p.SetState(562)
			p.Function_call_args()
		}

	}
	{
		p.SetState(566)
		p.Comment()
	}

	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 = modelicaParserRULE_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 = modelicaParserRULE_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ICommentContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IComponent_referenceContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IOutput_expression_listContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFunction_call_argsContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IIf_statementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFor_statementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWhile_statementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWhen_statementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (p *modelicaParser) Statement() (localctx IStatementContext) {
	this := p
	_ = this

	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, modelicaParserRULE_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.EnterOuterAlt(localctx, 1)
	p.SetState(587)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__86, modelicaParserIDENT:
		{
			p.SetState(568)
			p.Component_reference()
		}
		p.SetState(572)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__46:
			{
				p.SetState(569)
				p.Match(modelicaParserT__46)
			}
			{
				p.SetState(570)
				p.Expression()
			}

		case modelicaParserT__21:
			{
				p.SetState(571)
				p.Function_call_args()
			}

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

	case modelicaParserT__21:
		{
			p.SetState(574)
			p.Match(modelicaParserT__21)
		}
		{
			p.SetState(575)
			p.Output_expression_list()
		}
		{
			p.SetState(576)
			p.Match(modelicaParserT__23)
		}
		{
			p.SetState(577)
			p.Match(modelicaParserT__46)
		}
		{
			p.SetState(578)
			p.Component_reference()
		}
		{
			p.SetState(579)
			p.Function_call_args()
		}

	case modelicaParserT__51:
		{
			p.SetState(581)
			p.Match(modelicaParserT__51)
		}

	case modelicaParserT__52:
		{
			p.SetState(582)
			p.Match(modelicaParserT__52)
		}

	case modelicaParserT__45:
		{
			p.SetState(583)
			p.If_statement()
		}

	case modelicaParserT__56:
		{
			p.SetState(584)
			p.For_statement()
		}

	case modelicaParserT__59:
		{
			p.SetState(585)
			p.While_statement()
		}

	case modelicaParserT__60:
		{
			p.SetState(586)
			p.When_statement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(589)
		p.Comment()
	}

	return localctx
}

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

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

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

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

func NewEmptyIf_equationContext() *If_equationContext {
	var p = new(If_equationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_if_equation
	return p
}

func (*If_equationContext) IsIf_equationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_if_equation

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *If_equationContext) AllEquation() []IEquationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEquationContext)(nil)).Elem())
	var tst = make([]IEquationContext, len(ts))

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

	return tst
}

func (s *If_equationContext) Equation(i int) IEquationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEquationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEquationContext)
}

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

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

func (s *If_equationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterIf_equation(s)
	}
}

func (s *If_equationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitIf_equation(s)
	}
}

func (p *modelicaParser) If_equation() (localctx IIf_equationContext) {
	this := p
	_ = this

	localctx = NewIf_equationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, modelicaParserRULE_if_equation)
	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(591)
		p.Match(modelicaParserT__45)
	}
	{
		p.SetState(592)
		p.Expression()
	}
	{
		p.SetState(593)
		p.Match(modelicaParserT__53)
	}
	p.SetState(599)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(594)
				p.Equation()
			}
			{
				p.SetState(595)
				p.Match(modelicaParserT__1)
			}

		}
		p.SetState(601)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext())
	}
	p.SetState(615)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__54 {
		{
			p.SetState(602)
			p.Match(modelicaParserT__54)
		}
		{
			p.SetState(603)
			p.Expression()
		}
		{
			p.SetState(604)
			p.Match(modelicaParserT__53)
		}
		p.SetState(610)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(605)
					p.Equation()
				}
				{
					p.SetState(606)
					p.Match(modelicaParserT__1)
				}

			}
			p.SetState(612)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext())
		}

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

	if _la == modelicaParserT__55 {
		{
			p.SetState(618)
			p.Match(modelicaParserT__55)
		}
		p.SetState(624)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(619)
					p.Equation()
				}
				{
					p.SetState(620)
					p.Match(modelicaParserT__1)
				}

			}
			p.SetState(626)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext())
		}

	}
	{
		p.SetState(629)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(630)
		p.Match(modelicaParserT__45)
	}

	return localctx
}

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

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

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

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

func NewEmptyIf_statementContext() *If_statementContext {
	var p = new(If_statementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_if_statement
	return p
}

func (*If_statementContext) IsIf_statementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_if_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterIf_statement(s)
	}
}

func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitIf_statement(s)
	}
}

func (p *modelicaParser) If_statement() (localctx IIf_statementContext) {
	this := p
	_ = this

	localctx = NewIf_statementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, modelicaParserRULE_if_statement)
	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(modelicaParserT__45)
	}
	{
		p.SetState(633)
		p.Expression()
	}
	{
		p.SetState(634)
		p.Match(modelicaParserT__53)
	}
	p.SetState(640)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(635)
			p.Statement()
		}
		{
			p.SetState(636)
			p.Match(modelicaParserT__1)
		}

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

	for _la == modelicaParserT__54 {
		{
			p.SetState(643)
			p.Match(modelicaParserT__54)
		}
		{
			p.SetState(644)
			p.Expression()
		}
		{
			p.SetState(645)
			p.Match(modelicaParserT__53)
		}
		p.SetState(651)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
			{
				p.SetState(646)
				p.Statement()
			}
			{
				p.SetState(647)
				p.Match(modelicaParserT__1)
			}

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

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

	if _la == modelicaParserT__55 {
		{
			p.SetState(659)
			p.Match(modelicaParserT__55)
		}
		p.SetState(665)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
			{
				p.SetState(660)
				p.Statement()
			}
			{
				p.SetState(661)
				p.Match(modelicaParserT__1)
			}

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

	}
	{
		p.SetState(670)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(671)
		p.Match(modelicaParserT__45)
	}

	return localctx
}

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

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

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

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

func NewEmptyFor_equationContext() *For_equationContext {
	var p = new(For_equationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_for_equation
	return p
}

func (*For_equationContext) IsFor_equationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_for_equation

	return p
}

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

func (s *For_equationContext) For_indices() IFor_indicesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFor_indicesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFor_indicesContext)
}

func (s *For_equationContext) AllEquation() []IEquationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEquationContext)(nil)).Elem())
	var tst = make([]IEquationContext, len(ts))

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

	return tst
}

func (s *For_equationContext) Equation(i int) IEquationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEquationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEquationContext)
}

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

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

func (s *For_equationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFor_equation(s)
	}
}

func (s *For_equationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFor_equation(s)
	}
}

func (p *modelicaParser) For_equation() (localctx IFor_equationContext) {
	this := p
	_ = this

	localctx = NewFor_equationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, modelicaParserRULE_for_equation)

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

	defer func() {
		if err := recover(); err != 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(673)
		p.Match(modelicaParserT__56)
	}
	{
		p.SetState(674)
		p.For_indices()
	}
	{
		p.SetState(675)
		p.Match(modelicaParserT__57)
	}
	p.SetState(681)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(676)
				p.Equation()
			}
			{
				p.SetState(677)
				p.Match(modelicaParserT__1)
			}

		}
		p.SetState(683)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext())
	}
	{
		p.SetState(684)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(685)
		p.Match(modelicaParserT__56)
	}

	return localctx
}

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

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

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

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

func NewEmptyFor_statementContext() *For_statementContext {
	var p = new(For_statementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_for_statement
	return p
}

func (*For_statementContext) IsFor_statementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_for_statement

	return p
}

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

func (s *For_statementContext) For_indices() IFor_indicesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFor_indicesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFor_indicesContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *For_statementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFor_statement(s)
	}
}

func (s *For_statementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFor_statement(s)
	}
}

func (p *modelicaParser) For_statement() (localctx IFor_statementContext) {
	this := p
	_ = this

	localctx = NewFor_statementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, modelicaParserRULE_for_statement)
	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(687)
		p.Match(modelicaParserT__56)
	}
	{
		p.SetState(688)
		p.For_indices()
	}
	{
		p.SetState(689)
		p.Match(modelicaParserT__57)
	}
	p.SetState(695)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(690)
			p.Statement()
		}
		{
			p.SetState(691)
			p.Match(modelicaParserT__1)
		}

		p.SetState(697)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(698)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(699)
		p.Match(modelicaParserT__56)
	}

	return localctx
}

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

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

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

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

func NewEmptyFor_indicesContext() *For_indicesContext {
	var p = new(For_indicesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_for_indices
	return p
}

func (*For_indicesContext) IsFor_indicesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_for_indices

	return p
}

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

func (s *For_indicesContext) AllFor_index() []IFor_indexContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFor_indexContext)(nil)).Elem())
	var tst = make([]IFor_indexContext, len(ts))

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

	return tst
}

func (s *For_indicesContext) For_index(i int) IFor_indexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFor_indexContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFor_indexContext)
}

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

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

func (s *For_indicesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFor_indices(s)
	}
}

func (s *For_indicesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFor_indices(s)
	}
}

func (p *modelicaParser) For_indices() (localctx IFor_indicesContext) {
	this := p
	_ = this

	localctx = NewFor_indicesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, modelicaParserRULE_for_indices)
	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(701)
		p.For_index()
	}
	p.SetState(706)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(702)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(703)
			p.For_index()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFor_indexContext() *For_indexContext {
	var p = new(For_indexContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_for_index
	return p
}

func (*For_indexContext) IsFor_indexContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_for_index

	return p
}

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

func (s *For_indexContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *For_indexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFor_index(s)
	}
}

func (s *For_indexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFor_index(s)
	}
}

func (p *modelicaParser) For_index() (localctx IFor_indexContext) {
	this := p
	_ = this

	localctx = NewFor_indexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, modelicaParserRULE_for_index)
	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(709)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(712)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__58 {
		{
			p.SetState(710)
			p.Match(modelicaParserT__58)
		}
		{
			p.SetState(711)
			p.Expression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyWhile_statementContext() *While_statementContext {
	var p = new(While_statementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_while_statement
	return p
}

func (*While_statementContext) IsWhile_statementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_while_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *While_statementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterWhile_statement(s)
	}
}

func (s *While_statementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitWhile_statement(s)
	}
}

func (p *modelicaParser) While_statement() (localctx IWhile_statementContext) {
	this := p
	_ = this

	localctx = NewWhile_statementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, modelicaParserRULE_while_statement)
	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(714)
		p.Match(modelicaParserT__59)
	}
	{
		p.SetState(715)
		p.Expression()
	}
	{
		p.SetState(716)
		p.Match(modelicaParserT__57)
	}
	p.SetState(722)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(717)
			p.Statement()
		}
		{
			p.SetState(718)
			p.Match(modelicaParserT__1)
		}

		p.SetState(724)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(725)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(726)
		p.Match(modelicaParserT__59)
	}

	return localctx
}

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

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

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

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

func NewEmptyWhen_equationContext() *When_equationContext {
	var p = new(When_equationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_when_equation
	return p
}

func (*When_equationContext) IsWhen_equationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_when_equation

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *When_equationContext) AllEquation() []IEquationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEquationContext)(nil)).Elem())
	var tst = make([]IEquationContext, len(ts))

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

	return tst
}

func (s *When_equationContext) Equation(i int) IEquationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEquationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEquationContext)
}

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

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

func (s *When_equationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterWhen_equation(s)
	}
}

func (s *When_equationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitWhen_equation(s)
	}
}

func (p *modelicaParser) When_equation() (localctx IWhen_equationContext) {
	this := p
	_ = this

	localctx = NewWhen_equationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, modelicaParserRULE_when_equation)
	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(728)
		p.Match(modelicaParserT__60)
	}
	{
		p.SetState(729)
		p.Expression()
	}
	{
		p.SetState(730)
		p.Match(modelicaParserT__53)
	}
	p.SetState(736)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(731)
				p.Equation()
			}
			{
				p.SetState(732)
				p.Match(modelicaParserT__1)
			}

		}
		p.SetState(738)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext())
	}
	p.SetState(752)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__61 {
		{
			p.SetState(739)
			p.Match(modelicaParserT__61)
		}
		{
			p.SetState(740)
			p.Expression()
		}
		{
			p.SetState(741)
			p.Match(modelicaParserT__53)
		}
		p.SetState(747)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 91, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(742)
					p.Equation()
				}
				{
					p.SetState(743)
					p.Match(modelicaParserT__1)
				}

			}
			p.SetState(749)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 91, p.GetParserRuleContext())
		}

		p.SetState(754)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(755)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(756)
		p.Match(modelicaParserT__60)
	}

	return localctx
}

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

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

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

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

func NewEmptyWhen_statementContext() *When_statementContext {
	var p = new(When_statementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_when_statement
	return p
}

func (*When_statementContext) IsWhen_statementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_when_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *When_statementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterWhen_statement(s)
	}
}

func (s *When_statementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitWhen_statement(s)
	}
}

func (p *modelicaParser) When_statement() (localctx IWhen_statementContext) {
	this := p
	_ = this

	localctx = NewWhen_statementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, modelicaParserRULE_when_statement)
	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(758)
		p.Match(modelicaParserT__60)
	}
	{
		p.SetState(759)
		p.Expression()
	}
	{
		p.SetState(760)
		p.Match(modelicaParserT__53)
	}
	p.SetState(766)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
		{
			p.SetState(761)
			p.Statement()
		}
		{
			p.SetState(762)
			p.Match(modelicaParserT__1)
		}

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

	for _la == modelicaParserT__61 {
		{
			p.SetState(769)
			p.Match(modelicaParserT__61)
		}
		{
			p.SetState(770)
			p.Expression()
		}
		{
			p.SetState(771)
			p.Match(modelicaParserT__53)
		}
		p.SetState(777)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__21 || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__51-46))|(1<<(modelicaParserT__52-46))|(1<<(modelicaParserT__56-46))|(1<<(modelicaParserT__59-46))|(1<<(modelicaParserT__60-46)))) != 0) || _la == modelicaParserT__86 || _la == modelicaParserIDENT {
			{
				p.SetState(772)
				p.Statement()
			}
			{
				p.SetState(773)
				p.Match(modelicaParserT__1)
			}

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

		p.SetState(784)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(785)
		p.Match(modelicaParserT__17)
	}
	{
		p.SetState(786)
		p.Match(modelicaParserT__60)
	}

	return localctx
}

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

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

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

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

func NewEmptyConnect_clauseContext() *Connect_clauseContext {
	var p = new(Connect_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_connect_clause
	return p
}

func (*Connect_clauseContext) IsConnect_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_connect_clause

	return p
}

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

func (s *Connect_clauseContext) AllComponent_reference() []IComponent_referenceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IComponent_referenceContext)(nil)).Elem())
	var tst = make([]IComponent_referenceContext, len(ts))

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

	return tst
}

func (s *Connect_clauseContext) Component_reference(i int) IComponent_referenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_referenceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IComponent_referenceContext)
}

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

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

func (s *Connect_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterConnect_clause(s)
	}
}

func (s *Connect_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitConnect_clause(s)
	}
}

func (p *modelicaParser) Connect_clause() (localctx IConnect_clauseContext) {
	this := p
	_ = this

	localctx = NewConnect_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, modelicaParserRULE_connect_clause)

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

	defer func() {
		if err := recover(); err != nil {
			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(788)
		p.Match(modelicaParserT__62)
	}
	{
		p.SetState(789)
		p.Match(modelicaParserT__21)
	}
	{
		p.SetState(790)
		p.Component_reference()
	}
	{
		p.SetState(791)
		p.Match(modelicaParserT__25)
	}
	{
		p.SetState(792)
		p.Component_reference()
	}
	{
		p.SetState(793)
		p.Match(modelicaParserT__23)
	}

	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 = modelicaParserRULE_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 = modelicaParserRULE_expression

	return p
}

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

func (s *ExpressionContext) Simple_expression() ISimple_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimple_expressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimple_expressionContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *modelicaParser) Expression() (localctx IExpressionContext) {
	this := p
	_ = this

	localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, modelicaParserRULE_expression)
	var _la int

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

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

	p.SetState(813)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__17, modelicaParserT__21, modelicaParserT__24, modelicaParserT__48, modelicaParserT__65, modelicaParserT__72, modelicaParserT__73, modelicaParserT__74, modelicaParserT__75, modelicaParserT__81, modelicaParserT__82, modelicaParserT__83, modelicaParserT__85, modelicaParserT__86, modelicaParserIDENT, modelicaParserSTRING, modelicaParserUNSIGNED_NUMBER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(795)
			p.Simple_expression()
		}

	case modelicaParserT__45:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(796)
			p.Match(modelicaParserT__45)
		}
		{
			p.SetState(797)
			p.Expression()
		}
		{
			p.SetState(798)
			p.Match(modelicaParserT__53)
		}
		{
			p.SetState(799)
			p.Expression()
		}
		p.SetState(807)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__54 {
			{
				p.SetState(800)
				p.Match(modelicaParserT__54)
			}
			{
				p.SetState(801)
				p.Expression()
			}
			{
				p.SetState(802)
				p.Match(modelicaParserT__53)
			}
			{
				p.SetState(803)
				p.Expression()
			}

			p.SetState(809)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(810)
			p.Match(modelicaParserT__55)
		}
		{
			p.SetState(811)
			p.Expression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptySimple_expressionContext() *Simple_expressionContext {
	var p = new(Simple_expressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_simple_expression
	return p
}

func (*Simple_expressionContext) IsSimple_expressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_simple_expression

	return p
}

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

func (s *Simple_expressionContext) AllLogical_expression() []ILogical_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILogical_expressionContext)(nil)).Elem())
	var tst = make([]ILogical_expressionContext, len(ts))

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

	return tst
}

func (s *Simple_expressionContext) Logical_expression(i int) ILogical_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogical_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILogical_expressionContext)
}

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

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

func (s *Simple_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterSimple_expression(s)
	}
}

func (s *Simple_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitSimple_expression(s)
	}
}

func (p *modelicaParser) Simple_expression() (localctx ISimple_expressionContext) {
	this := p
	_ = this

	localctx = NewSimple_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, modelicaParserRULE_simple_expression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(815)
		p.Logical_expression()
	}
	p.SetState(822)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__22 {
		{
			p.SetState(816)
			p.Match(modelicaParserT__22)
		}
		{
			p.SetState(817)
			p.Logical_expression()
		}
		p.SetState(820)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__22 {
			{
				p.SetState(818)
				p.Match(modelicaParserT__22)
			}
			{
				p.SetState(819)
				p.Logical_expression()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyLogical_expressionContext() *Logical_expressionContext {
	var p = new(Logical_expressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_logical_expression
	return p
}

func (*Logical_expressionContext) IsLogical_expressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_logical_expression

	return p
}

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

func (s *Logical_expressionContext) AllLogical_term() []ILogical_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILogical_termContext)(nil)).Elem())
	var tst = make([]ILogical_termContext, len(ts))

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

	return tst
}

func (s *Logical_expressionContext) Logical_term(i int) ILogical_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogical_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILogical_termContext)
}

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

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

func (s *Logical_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterLogical_expression(s)
	}
}

func (s *Logical_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitLogical_expression(s)
	}
}

func (p *modelicaParser) Logical_expression() (localctx ILogical_expressionContext) {
	this := p
	_ = this

	localctx = NewLogical_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, modelicaParserRULE_logical_expression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(824)
		p.Logical_term()
	}
	p.SetState(829)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__63 {
		{
			p.SetState(825)
			p.Match(modelicaParserT__63)
		}
		{
			p.SetState(826)
			p.Logical_term()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLogical_termContext() *Logical_termContext {
	var p = new(Logical_termContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_logical_term
	return p
}

func (*Logical_termContext) IsLogical_termContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_logical_term

	return p
}

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

func (s *Logical_termContext) AllLogical_factor() []ILogical_factorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILogical_factorContext)(nil)).Elem())
	var tst = make([]ILogical_factorContext, len(ts))

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

	return tst
}

func (s *Logical_termContext) Logical_factor(i int) ILogical_factorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogical_factorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILogical_factorContext)
}

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

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

func (s *Logical_termContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterLogical_term(s)
	}
}

func (s *Logical_termContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitLogical_term(s)
	}
}

func (p *modelicaParser) Logical_term() (localctx ILogical_termContext) {
	this := p
	_ = this

	localctx = NewLogical_termContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, modelicaParserRULE_logical_term)
	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(832)
		p.Logical_factor()
	}
	p.SetState(837)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__64 {
		{
			p.SetState(833)
			p.Match(modelicaParserT__64)
		}
		{
			p.SetState(834)
			p.Logical_factor()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLogical_factorContext() *Logical_factorContext {
	var p = new(Logical_factorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_logical_factor
	return p
}

func (*Logical_factorContext) IsLogical_factorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_logical_factor

	return p
}

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

func (s *Logical_factorContext) Relation() IRelationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelationContext)
}

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

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

func (s *Logical_factorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterLogical_factor(s)
	}
}

func (s *Logical_factorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitLogical_factor(s)
	}
}

func (p *modelicaParser) Logical_factor() (localctx ILogical_factorContext) {
	this := p
	_ = this

	localctx = NewLogical_factorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, modelicaParserRULE_logical_factor)
	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(841)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__65 {
		{
			p.SetState(840)
			p.Match(modelicaParserT__65)
		}

	}
	{
		p.SetState(843)
		p.Relation()
	}

	return localctx
}

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

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

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

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

func NewEmptyRelationContext() *RelationContext {
	var p = new(RelationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_relation
	return p
}

func (*RelationContext) IsRelationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_relation

	return p
}

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

func (s *RelationContext) AllArithmetic_expression() []IArithmetic_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArithmetic_expressionContext)(nil)).Elem())
	var tst = make([]IArithmetic_expressionContext, len(ts))

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

	return tst
}

func (s *RelationContext) Arithmetic_expression(i int) IArithmetic_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArithmetic_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArithmetic_expressionContext)
}

func (s *RelationContext) Rel_op() IRel_opContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRel_opContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRel_opContext)
}

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

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

func (s *RelationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterRelation(s)
	}
}

func (s *RelationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitRelation(s)
	}
}

func (p *modelicaParser) Relation() (localctx IRelationContext) {
	this := p
	_ = this

	localctx = NewRelationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, modelicaParserRULE_relation)
	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(845)
		p.Arithmetic_expression()
	}
	p.SetState(849)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(modelicaParserT__66-67))|(1<<(modelicaParserT__67-67))|(1<<(modelicaParserT__68-67))|(1<<(modelicaParserT__69-67))|(1<<(modelicaParserT__70-67))|(1<<(modelicaParserT__71-67)))) != 0 {
		{
			p.SetState(846)
			p.Rel_op()
		}
		{
			p.SetState(847)
			p.Arithmetic_expression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRel_opContext() *Rel_opContext {
	var p = new(Rel_opContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_rel_op
	return p
}

func (*Rel_opContext) IsRel_opContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_rel_op

	return p
}

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

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

func (s *Rel_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterRel_op(s)
	}
}

func (s *Rel_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitRel_op(s)
	}
}

func (p *modelicaParser) Rel_op() (localctx IRel_opContext) {
	this := p
	_ = this

	localctx = NewRel_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, modelicaParserRULE_rel_op)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(851)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(modelicaParserT__66-67))|(1<<(modelicaParserT__67-67))|(1<<(modelicaParserT__68-67))|(1<<(modelicaParserT__69-67))|(1<<(modelicaParserT__70-67))|(1<<(modelicaParserT__71-67)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyArithmetic_expressionContext() *Arithmetic_expressionContext {
	var p = new(Arithmetic_expressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_arithmetic_expression
	return p
}

func (*Arithmetic_expressionContext) IsArithmetic_expressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_arithmetic_expression

	return p
}

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

func (s *Arithmetic_expressionContext) AllTerm() []ITermContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITermContext)(nil)).Elem())
	var tst = make([]ITermContext, len(ts))

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

	return tst
}

func (s *Arithmetic_expressionContext) Term(i int) ITermContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITermContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITermContext)
}

func (s *Arithmetic_expressionContext) AllAdd_op() []IAdd_opContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAdd_opContext)(nil)).Elem())
	var tst = make([]IAdd_opContext, len(ts))

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

	return tst
}

func (s *Arithmetic_expressionContext) Add_op(i int) IAdd_opContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdd_opContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAdd_opContext)
}

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

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

func (s *Arithmetic_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterArithmetic_expression(s)
	}
}

func (s *Arithmetic_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitArithmetic_expression(s)
	}
}

func (p *modelicaParser) Arithmetic_expression() (localctx IArithmetic_expressionContext) {
	this := p
	_ = this

	localctx = NewArithmetic_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, modelicaParserRULE_arithmetic_expression)
	var _la int

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

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

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

	if ((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(modelicaParserT__72-73))|(1<<(modelicaParserT__73-73))|(1<<(modelicaParserT__74-73))|(1<<(modelicaParserT__75-73)))) != 0 {
		{
			p.SetState(853)
			p.Add_op()
		}

	}
	{
		p.SetState(856)
		p.Term()
	}
	p.SetState(862)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(modelicaParserT__72-73))|(1<<(modelicaParserT__73-73))|(1<<(modelicaParserT__74-73))|(1<<(modelicaParserT__75-73)))) != 0 {
		{
			p.SetState(857)
			p.Add_op()
		}
		{
			p.SetState(858)
			p.Term()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAdd_opContext() *Add_opContext {
	var p = new(Add_opContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_add_op
	return p
}

func (*Add_opContext) IsAdd_opContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_add_op

	return p
}

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

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

func (s *Add_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterAdd_op(s)
	}
}

func (s *Add_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitAdd_op(s)
	}
}

func (p *modelicaParser) Add_op() (localctx IAdd_opContext) {
	this := p
	_ = this

	localctx = NewAdd_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, modelicaParserRULE_add_op)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(865)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(modelicaParserT__72-73))|(1<<(modelicaParserT__73-73))|(1<<(modelicaParserT__74-73))|(1<<(modelicaParserT__75-73)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyTermContext() *TermContext {
	var p = new(TermContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_term
	return p
}

func (*TermContext) IsTermContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_term

	return p
}

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

func (s *TermContext) AllFactor() []IFactorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFactorContext)(nil)).Elem())
	var tst = make([]IFactorContext, len(ts))

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

	return tst
}

func (s *TermContext) Factor(i int) IFactorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFactorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFactorContext)
}

func (s *TermContext) AllMul_op() []IMul_opContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMul_opContext)(nil)).Elem())
	var tst = make([]IMul_opContext, len(ts))

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

	return tst
}

func (s *TermContext) Mul_op(i int) IMul_opContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMul_opContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IMul_opContext)
}

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

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

func (s *TermContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterTerm(s)
	}
}

func (s *TermContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitTerm(s)
	}
}

func (p *modelicaParser) Term() (localctx ITermContext) {
	this := p
	_ = this

	localctx = NewTermContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, modelicaParserRULE_term)
	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(867)
		p.Factor()
	}
	p.SetState(873)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__34 || (((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(modelicaParserT__76-77))|(1<<(modelicaParserT__77-77))|(1<<(modelicaParserT__78-77)))) != 0) {
		{
			p.SetState(868)
			p.Mul_op()
		}
		{
			p.SetState(869)
			p.Factor()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyMul_opContext() *Mul_opContext {
	var p = new(Mul_opContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_mul_op
	return p
}

func (*Mul_opContext) IsMul_opContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_mul_op

	return p
}

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

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

func (s *Mul_opContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterMul_op(s)
	}
}

func (s *Mul_opContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitMul_op(s)
	}
}

func (p *modelicaParser) Mul_op() (localctx IMul_opContext) {
	this := p
	_ = this

	localctx = NewMul_opContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, modelicaParserRULE_mul_op)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(876)
		_la = p.GetTokenStream().LA(1)

		if !(_la == modelicaParserT__34 || (((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(modelicaParserT__76-77))|(1<<(modelicaParserT__77-77))|(1<<(modelicaParserT__78-77)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyFactorContext() *FactorContext {
	var p = new(FactorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_factor
	return p
}

func (*FactorContext) IsFactorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_factor

	return p
}

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

func (s *FactorContext) AllPrimary() []IPrimaryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPrimaryContext)(nil)).Elem())
	var tst = make([]IPrimaryContext, len(ts))

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

	return tst
}

func (s *FactorContext) Primary(i int) IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

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

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

func (s *FactorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFactor(s)
	}
}

func (s *FactorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFactor(s)
	}
}

func (p *modelicaParser) Factor() (localctx IFactorContext) {
	this := p
	_ = this

	localctx = NewFactorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, modelicaParserRULE_factor)
	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(878)
		p.Primary()
	}
	p.SetState(881)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__79 || _la == modelicaParserT__80 {
		{
			p.SetState(879)
			_la = p.GetTokenStream().LA(1)

			if !(_la == modelicaParserT__79 || _la == modelicaParserT__80) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(880)
			p.Primary()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyPrimaryContext() *PrimaryContext {
	var p = new(PrimaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_primary
	return p
}

func (*PrimaryContext) IsPrimaryContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_primary

	return p
}

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

func (s *PrimaryContext) UNSIGNED_NUMBER() antlr.TerminalNode {
	return s.GetToken(modelicaParserUNSIGNED_NUMBER, 0)
}

func (s *PrimaryContext) STRING() antlr.TerminalNode {
	return s.GetToken(modelicaParserSTRING, 0)
}

func (s *PrimaryContext) Function_call_args() IFunction_call_argsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_call_argsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_call_argsContext)
}

func (s *PrimaryContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *PrimaryContext) Component_reference() IComponent_referenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IComponent_referenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IComponent_referenceContext)
}

func (s *PrimaryContext) Output_expression_list() IOutput_expression_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOutput_expression_listContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOutput_expression_listContext)
}

func (s *PrimaryContext) AllExpression_list() []IExpression_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpression_listContext)(nil)).Elem())
	var tst = make([]IExpression_listContext, len(ts))

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

	return tst
}

func (s *PrimaryContext) Expression_list(i int) IExpression_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpression_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpression_listContext)
}

func (s *PrimaryContext) Function_arguments() IFunction_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_argumentsContext)
}

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

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

func (s *PrimaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterPrimary(s)
	}
}

func (s *PrimaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitPrimary(s)
	}
}

func (p *modelicaParser) Primary() (localctx IPrimaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, modelicaParserRULE_primary)
	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(914)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 110, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(883)
			p.Match(modelicaParserUNSIGNED_NUMBER)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(884)
			p.Match(modelicaParserSTRING)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(885)
			p.Match(modelicaParserT__81)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(886)
			p.Match(modelicaParserT__82)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		p.SetState(890)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__86, modelicaParserIDENT:
			{
				p.SetState(887)
				p.Name()
			}

		case modelicaParserT__24:
			{
				p.SetState(888)
				p.Match(modelicaParserT__24)
			}

		case modelicaParserT__48:
			{
				p.SetState(889)
				p.Match(modelicaParserT__48)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(892)
			p.Function_call_args()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(893)
			p.Component_reference()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(894)
			p.Match(modelicaParserT__21)
		}
		{
			p.SetState(895)
			p.Output_expression_list()
		}
		{
			p.SetState(896)
			p.Match(modelicaParserT__23)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(898)
			p.Match(modelicaParserT__83)
		}
		{
			p.SetState(899)
			p.Expression_list()
		}
		p.SetState(904)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__1 {
			{
				p.SetState(900)
				p.Match(modelicaParserT__1)
			}
			{
				p.SetState(901)
				p.Expression_list()
			}

			p.SetState(906)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(907)
			p.Match(modelicaParserT__84)
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(909)
			p.Match(modelicaParserT__85)
		}
		{
			p.SetState(910)
			p.Function_arguments()
		}
		{
			p.SetState(911)
			p.Match(modelicaParserT__36)
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(913)
			p.Match(modelicaParserT__17)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNameContext() *NameContext {
	var p = new(NameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_name
	return p
}

func (*NameContext) IsNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_name

	return p
}

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

func (s *NameContext) AllIDENT() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserIDENT)
}

func (s *NameContext) IDENT(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, i)
}

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

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

func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterName(s)
	}
}

func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitName(s)
	}
}

func (p *modelicaParser) Name() (localctx INameContext) {
	this := p
	_ = this

	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, modelicaParserRULE_name)
	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(917)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__86 {
		{
			p.SetState(916)
			p.Match(modelicaParserT__86)
		}

	}
	{
		p.SetState(919)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(924)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__86 {
		{
			p.SetState(920)
			p.Match(modelicaParserT__86)
		}
		{
			p.SetState(921)
			p.Match(modelicaParserIDENT)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyComponent_referenceContext() *Component_referenceContext {
	var p = new(Component_referenceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_component_reference
	return p
}

func (*Component_referenceContext) IsComponent_referenceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_component_reference

	return p
}

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

func (s *Component_referenceContext) AllIDENT() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserIDENT)
}

func (s *Component_referenceContext) IDENT(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, i)
}

func (s *Component_referenceContext) AllArray_subscripts() []IArray_subscriptsContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArray_subscriptsContext)(nil)).Elem())
	var tst = make([]IArray_subscriptsContext, len(ts))

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

	return tst
}

func (s *Component_referenceContext) Array_subscripts(i int) IArray_subscriptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArray_subscriptsContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArray_subscriptsContext)
}

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

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

func (s *Component_referenceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComponent_reference(s)
	}
}

func (s *Component_referenceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComponent_reference(s)
	}
}

func (p *modelicaParser) Component_reference() (localctx IComponent_referenceContext) {
	this := p
	_ = this

	localctx = NewComponent_referenceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, modelicaParserRULE_component_reference)
	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(928)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__86 {
		{
			p.SetState(927)
			p.Match(modelicaParserT__86)
		}

	}
	{
		p.SetState(930)
		p.Match(modelicaParserIDENT)
	}
	p.SetState(932)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__83 {
		{
			p.SetState(931)
			p.Array_subscripts()
		}

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

	for _la == modelicaParserT__86 {
		{
			p.SetState(934)
			p.Match(modelicaParserT__86)
		}
		{
			p.SetState(935)
			p.Match(modelicaParserIDENT)
		}
		p.SetState(937)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserT__83 {
			{
				p.SetState(936)
				p.Array_subscripts()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyFunction_call_argsContext() *Function_call_argsContext {
	var p = new(Function_call_argsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_function_call_args
	return p
}

func (*Function_call_argsContext) IsFunction_call_argsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_function_call_args

	return p
}

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

func (s *Function_call_argsContext) Function_arguments() IFunction_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_argumentsContext)
}

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

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

func (s *Function_call_argsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFunction_call_args(s)
	}
}

func (s *Function_call_argsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFunction_call_args(s)
	}
}

func (p *modelicaParser) Function_call_args() (localctx IFunction_call_argsContext) {
	this := p
	_ = this

	localctx = NewFunction_call_argsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, modelicaParserRULE_function_call_args)
	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(944)
		p.Match(modelicaParserT__21)
	}
	p.SetState(946)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<modelicaParserT__16)|(1<<modelicaParserT__17)|(1<<modelicaParserT__21)|(1<<modelicaParserT__24))) != 0) || (((_la-46)&-(0x1f+1)) == 0 && ((1<<uint((_la-46)))&((1<<(modelicaParserT__45-46))|(1<<(modelicaParserT__48-46))|(1<<(modelicaParserT__65-46))|(1<<(modelicaParserT__72-46))|(1<<(modelicaParserT__73-46))|(1<<(modelicaParserT__74-46))|(1<<(modelicaParserT__75-46)))) != 0) || (((_la-82)&-(0x1f+1)) == 0 && ((1<<uint((_la-82)))&((1<<(modelicaParserT__81-82))|(1<<(modelicaParserT__82-82))|(1<<(modelicaParserT__83-82))|(1<<(modelicaParserT__85-82))|(1<<(modelicaParserT__86-82))|(1<<(modelicaParserIDENT-82))|(1<<(modelicaParserSTRING-82))|(1<<(modelicaParserUNSIGNED_NUMBER-82)))) != 0) {
		{
			p.SetState(945)
			p.Function_arguments()
		}

	}
	{
		p.SetState(948)
		p.Match(modelicaParserT__23)
	}

	return localctx
}

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

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

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

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

func NewEmptyFunction_argumentsContext() *Function_argumentsContext {
	var p = new(Function_argumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_function_arguments
	return p
}

func (*Function_argumentsContext) IsFunction_argumentsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_function_arguments

	return p
}

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

func (s *Function_argumentsContext) Function_argument() IFunction_argumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_argumentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_argumentContext)
}

func (s *Function_argumentsContext) Function_arguments() IFunction_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_argumentsContext)
}

func (s *Function_argumentsContext) For_indices() IFor_indicesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFor_indicesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFor_indicesContext)
}

func (s *Function_argumentsContext) Named_arguments() INamed_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamed_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamed_argumentsContext)
}

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

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

func (s *Function_argumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFunction_arguments(s)
	}
}

func (s *Function_argumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFunction_arguments(s)
	}
}

func (p *modelicaParser) Function_arguments() (localctx IFunction_argumentsContext) {
	this := p
	_ = this

	localctx = NewFunction_argumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, modelicaParserRULE_function_arguments)

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

	defer func() {
		if err := recover(); err != nil {
			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(958)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(950)
			p.Function_argument()
		}
		p.SetState(955)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case modelicaParserT__25:
			{
				p.SetState(951)
				p.Match(modelicaParserT__25)
			}
			{
				p.SetState(952)
				p.Function_arguments()
			}

		case modelicaParserT__56:
			{
				p.SetState(953)
				p.Match(modelicaParserT__56)
			}
			{
				p.SetState(954)
				p.For_indices()
			}

		case modelicaParserT__23, modelicaParserT__36:

		default:
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(957)
			p.Named_arguments()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNamed_argumentsContext() *Named_argumentsContext {
	var p = new(Named_argumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_named_arguments
	return p
}

func (*Named_argumentsContext) IsNamed_argumentsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_named_arguments

	return p
}

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

func (s *Named_argumentsContext) Named_argument() INamed_argumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamed_argumentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamed_argumentContext)
}

func (s *Named_argumentsContext) Named_arguments() INamed_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamed_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamed_argumentsContext)
}

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

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

func (s *Named_argumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterNamed_arguments(s)
	}
}

func (s *Named_argumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitNamed_arguments(s)
	}
}

func (p *modelicaParser) Named_arguments() (localctx INamed_argumentsContext) {
	this := p
	_ = this

	localctx = NewNamed_argumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, modelicaParserRULE_named_arguments)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(960)
		p.Named_argument()
	}
	p.SetState(963)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__25 {
		{
			p.SetState(961)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(962)
			p.Named_arguments()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNamed_argumentContext() *Named_argumentContext {
	var p = new(Named_argumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_named_argument
	return p
}

func (*Named_argumentContext) IsNamed_argumentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_named_argument

	return p
}

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

func (s *Named_argumentContext) IDENT() antlr.TerminalNode {
	return s.GetToken(modelicaParserIDENT, 0)
}

func (s *Named_argumentContext) Function_argument() IFunction_argumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_argumentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_argumentContext)
}

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

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

func (s *Named_argumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterNamed_argument(s)
	}
}

func (s *Named_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitNamed_argument(s)
	}
}

func (p *modelicaParser) Named_argument() (localctx INamed_argumentContext) {
	this := p
	_ = this

	localctx = NewNamed_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, modelicaParserRULE_named_argument)

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

	defer func() {
		if err := recover(); err != nil {
			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(965)
		p.Match(modelicaParserIDENT)
	}
	{
		p.SetState(966)
		p.Match(modelicaParserT__19)
	}
	{
		p.SetState(967)
		p.Function_argument()
	}

	return localctx
}

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

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

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

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

func NewEmptyFunction_argumentContext() *Function_argumentContext {
	var p = new(Function_argumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_function_argument
	return p
}

func (*Function_argumentContext) IsFunction_argumentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_function_argument

	return p
}

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

func (s *Function_argumentContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Function_argumentContext) Named_arguments() INamed_argumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamed_argumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamed_argumentsContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *Function_argumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterFunction_argument(s)
	}
}

func (s *Function_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitFunction_argument(s)
	}
}

func (p *modelicaParser) Function_argument() (localctx IFunction_argumentContext) {
	this := p
	_ = this

	localctx = NewFunction_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, modelicaParserRULE_function_argument)
	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(978)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__16:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(969)
			p.Match(modelicaParserT__16)
		}
		{
			p.SetState(970)
			p.Name()
		}
		{
			p.SetState(971)
			p.Match(modelicaParserT__21)
		}
		p.SetState(973)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == modelicaParserIDENT {
			{
				p.SetState(972)
				p.Named_arguments()
			}

		}
		{
			p.SetState(975)
			p.Match(modelicaParserT__23)
		}

	case modelicaParserT__17, modelicaParserT__21, modelicaParserT__24, modelicaParserT__45, modelicaParserT__48, modelicaParserT__65, modelicaParserT__72, modelicaParserT__73, modelicaParserT__74, modelicaParserT__75, modelicaParserT__81, modelicaParserT__82, modelicaParserT__83, modelicaParserT__85, modelicaParserT__86, modelicaParserIDENT, modelicaParserSTRING, modelicaParserUNSIGNED_NUMBER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(977)
			p.Expression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOutput_expression_listContext() *Output_expression_listContext {
	var p = new(Output_expression_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_output_expression_list
	return p
}

func (*Output_expression_listContext) IsOutput_expression_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_output_expression_list

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

func (s *Output_expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Output_expression_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterOutput_expression_list(s)
	}
}

func (s *Output_expression_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitOutput_expression_list(s)
	}
}

func (p *modelicaParser) Output_expression_list() (localctx IOutput_expression_listContext) {
	this := p
	_ = this

	localctx = NewOutput_expression_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, modelicaParserRULE_output_expression_list)
	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(981)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-18)&-(0x1f+1)) == 0 && ((1<<uint((_la-18)))&((1<<(modelicaParserT__17-18))|(1<<(modelicaParserT__21-18))|(1<<(modelicaParserT__24-18))|(1<<(modelicaParserT__45-18))|(1<<(modelicaParserT__48-18)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(modelicaParserT__65-66))|(1<<(modelicaParserT__72-66))|(1<<(modelicaParserT__73-66))|(1<<(modelicaParserT__74-66))|(1<<(modelicaParserT__75-66))|(1<<(modelicaParserT__81-66))|(1<<(modelicaParserT__82-66))|(1<<(modelicaParserT__83-66))|(1<<(modelicaParserT__85-66))|(1<<(modelicaParserT__86-66))|(1<<(modelicaParserIDENT-66))|(1<<(modelicaParserSTRING-66))|(1<<(modelicaParserUNSIGNED_NUMBER-66)))) != 0) {
		{
			p.SetState(980)
			p.Expression()
		}

	}
	p.SetState(989)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(983)
			p.Match(modelicaParserT__25)
		}
		p.SetState(985)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-18)&-(0x1f+1)) == 0 && ((1<<uint((_la-18)))&((1<<(modelicaParserT__17-18))|(1<<(modelicaParserT__21-18))|(1<<(modelicaParserT__24-18))|(1<<(modelicaParserT__45-18))|(1<<(modelicaParserT__48-18)))) != 0) || (((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(modelicaParserT__65-66))|(1<<(modelicaParserT__72-66))|(1<<(modelicaParserT__73-66))|(1<<(modelicaParserT__74-66))|(1<<(modelicaParserT__75-66))|(1<<(modelicaParserT__81-66))|(1<<(modelicaParserT__82-66))|(1<<(modelicaParserT__83-66))|(1<<(modelicaParserT__85-66))|(1<<(modelicaParserT__86-66))|(1<<(modelicaParserIDENT-66))|(1<<(modelicaParserSTRING-66))|(1<<(modelicaParserUNSIGNED_NUMBER-66)))) != 0) {
			{
				p.SetState(984)
				p.Expression()
			}

		}

		p.SetState(991)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IExpression_listContext is an interface to support dynamic dispatch.
type IExpression_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpression_listContext differentiates from other interfaces.
	IsExpression_listContext()
}

type Expression_listContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpression_listContext() *Expression_listContext {
	var p = new(Expression_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_expression_list
	return p
}

func (*Expression_listContext) IsExpression_listContext() {}

func NewExpression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_listContext {
	var p = new(Expression_listContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_expression_list

	return p
}

func (s *Expression_listContext) GetParser() antlr.Parser { return s.parser }

func (s *Expression_listContext) 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 *Expression_listContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *Expression_listContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Expression_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterExpression_list(s)
	}
}

func (s *Expression_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitExpression_list(s)
	}
}

func (p *modelicaParser) Expression_list() (localctx IExpression_listContext) {
	this := p
	_ = this

	localctx = NewExpression_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, modelicaParserRULE_expression_list)
	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(992)
		p.Expression()
	}
	p.SetState(997)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(993)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(994)
			p.Expression()
		}

		p.SetState(999)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IArray_subscriptsContext is an interface to support dynamic dispatch.
type IArray_subscriptsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArray_subscriptsContext differentiates from other interfaces.
	IsArray_subscriptsContext()
}

type Array_subscriptsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArray_subscriptsContext() *Array_subscriptsContext {
	var p = new(Array_subscriptsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_array_subscripts
	return p
}

func (*Array_subscriptsContext) IsArray_subscriptsContext() {}

func NewArray_subscriptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_subscriptsContext {
	var p = new(Array_subscriptsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_array_subscripts

	return p
}

func (s *Array_subscriptsContext) GetParser() antlr.Parser { return s.parser }

func (s *Array_subscriptsContext) AllSubscript_() []ISubscript_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISubscript_Context)(nil)).Elem())
	var tst = make([]ISubscript_Context, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISubscript_Context)
		}
	}

	return tst
}

func (s *Array_subscriptsContext) Subscript_(i int) ISubscript_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISubscript_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISubscript_Context)
}

func (s *Array_subscriptsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Array_subscriptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Array_subscriptsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterArray_subscripts(s)
	}
}

func (s *Array_subscriptsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitArray_subscripts(s)
	}
}

func (p *modelicaParser) Array_subscripts() (localctx IArray_subscriptsContext) {
	this := p
	_ = this

	localctx = NewArray_subscriptsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, modelicaParserRULE_array_subscripts)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1000)
		p.Match(modelicaParserT__83)
	}
	{
		p.SetState(1001)
		p.Subscript_()
	}
	p.SetState(1006)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == modelicaParserT__25 {
		{
			p.SetState(1002)
			p.Match(modelicaParserT__25)
		}
		{
			p.SetState(1003)
			p.Subscript_()
		}

		p.SetState(1008)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1009)
		p.Match(modelicaParserT__84)
	}

	return localctx
}

// ISubscript_Context is an interface to support dynamic dispatch.
type ISubscript_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubscript_Context differentiates from other interfaces.
	IsSubscript_Context()
}

type Subscript_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySubscript_Context() *Subscript_Context {
	var p = new(Subscript_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_subscript_
	return p
}

func (*Subscript_Context) IsSubscript_Context() {}

func NewSubscript_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subscript_Context {
	var p = new(Subscript_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_subscript_

	return p
}

func (s *Subscript_Context) GetParser() antlr.Parser { return s.parser }

func (s *Subscript_Context) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *Subscript_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Subscript_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Subscript_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterSubscript_(s)
	}
}

func (s *Subscript_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitSubscript_(s)
	}
}

func (p *modelicaParser) Subscript_() (localctx ISubscript_Context) {
	this := p
	_ = this

	localctx = NewSubscript_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, modelicaParserRULE_subscript_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1013)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case modelicaParserT__22:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1011)
			p.Match(modelicaParserT__22)
		}

	case modelicaParserT__17, modelicaParserT__21, modelicaParserT__24, modelicaParserT__45, modelicaParserT__48, modelicaParserT__65, modelicaParserT__72, modelicaParserT__73, modelicaParserT__74, modelicaParserT__75, modelicaParserT__81, modelicaParserT__82, modelicaParserT__83, modelicaParserT__85, modelicaParserT__86, modelicaParserIDENT, modelicaParserSTRING, modelicaParserUNSIGNED_NUMBER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1012)
			p.Expression()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ICommentContext is an interface to support dynamic dispatch.
type ICommentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCommentContext differentiates from other interfaces.
	IsCommentContext()
}

type CommentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCommentContext() *CommentContext {
	var p = new(CommentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_comment
	return p
}

func (*CommentContext) IsCommentContext() {}

func NewCommentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentContext {
	var p = new(CommentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_comment

	return p
}

func (s *CommentContext) GetParser() antlr.Parser { return s.parser }

func (s *CommentContext) String_comment() IString_commentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IString_commentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IString_commentContext)
}

func (s *CommentContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *CommentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CommentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CommentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterComment(s)
	}
}

func (s *CommentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitComment(s)
	}
}

func (p *modelicaParser) Comment() (localctx ICommentContext) {
	this := p
	_ = this

	localctx = NewCommentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, modelicaParserRULE_comment)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1015)
		p.String_comment()
	}
	p.SetState(1017)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserT__87 {
		{
			p.SetState(1016)
			p.Annotation()
		}

	}

	return localctx
}

// IString_commentContext is an interface to support dynamic dispatch.
type IString_commentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsString_commentContext differentiates from other interfaces.
	IsString_commentContext()
}

type String_commentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyString_commentContext() *String_commentContext {
	var p = new(String_commentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_string_comment
	return p
}

func (*String_commentContext) IsString_commentContext() {}

func NewString_commentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_commentContext {
	var p = new(String_commentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_string_comment

	return p
}

func (s *String_commentContext) GetParser() antlr.Parser { return s.parser }

func (s *String_commentContext) AllSTRING() []antlr.TerminalNode {
	return s.GetTokens(modelicaParserSTRING)
}

func (s *String_commentContext) STRING(i int) antlr.TerminalNode {
	return s.GetToken(modelicaParserSTRING, i)
}

func (s *String_commentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *String_commentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *String_commentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterString_comment(s)
	}
}

func (s *String_commentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitString_comment(s)
	}
}

func (p *modelicaParser) String_comment() (localctx IString_commentContext) {
	this := p
	_ = this

	localctx = NewString_commentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, modelicaParserRULE_string_comment)
	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(1027)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == modelicaParserSTRING {
		{
			p.SetState(1019)
			p.Match(modelicaParserSTRING)
		}
		p.SetState(1024)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == modelicaParserT__72 {
			{
				p.SetState(1020)
				p.Match(modelicaParserT__72)
			}
			{
				p.SetState(1021)
				p.Match(modelicaParserSTRING)
			}

			p.SetState(1026)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IAnnotationContext is an interface to support dynamic dispatch.
type IAnnotationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationContext differentiates from other interfaces.
	IsAnnotationContext()
}

type AnnotationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationContext() *AnnotationContext {
	var p = new(AnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = modelicaParserRULE_annotation
	return p
}

func (*AnnotationContext) IsAnnotationContext() {}

func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext {
	var p = new(AnnotationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = modelicaParserRULE_annotation

	return p
}

func (s *AnnotationContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationContext) Class_modification() IClass_modificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClass_modificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClass_modificationContext)
}

func (s *AnnotationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.EnterAnnotation(s)
	}
}

func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(modelicaListener); ok {
		listenerT.ExitAnnotation(s)
	}
}

func (p *modelicaParser) Annotation() (localctx IAnnotationContext) {
	this := p
	_ = this

	localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, modelicaParserRULE_annotation)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1029)
		p.Match(modelicaParserT__87)
	}
	{
		p.SetState(1030)
		p.Class_modification()
	}

	return localctx
}
