// Code generated from Cobol85Preprocessor.g4 by ANTLR 4.7.2. DO NOT EDIT.

package cobol85preprocessor // Cobol85Preprocessor
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, 294, 680,
	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, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
	2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 75, 10, 2, 12, 2, 14, 2, 78,
	11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 5, 3, 84, 10, 3, 3, 3, 3, 3, 6, 3, 88, 10,
	3, 13, 3, 14, 3, 89, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 96, 10, 4, 3, 4, 7,
	4, 99, 10, 4, 12, 4, 14, 4, 102, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3,
	5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
	5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 126, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
	5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
	5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 151, 10, 5, 3, 5, 5, 5, 154,
	10, 5, 3, 5, 5, 5, 157, 10, 5, 3, 5, 5, 5, 160, 10, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 5, 5, 180, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	5, 5, 188, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 220, 10, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 228, 10, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 5, 5, 234, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 251, 10, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 324, 10, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 5, 5, 339, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	5, 5, 361, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5,
	371, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 377, 10, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5,
	393, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 402, 10, 5,
	3, 5, 5, 5, 405, 10, 5, 3, 5, 5, 5, 408, 10, 5, 3, 5, 5, 5, 411, 10, 5,
	3, 5, 5, 5, 414, 10, 5, 3, 5, 5, 5, 417, 10, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 5, 5, 437, 10, 5, 3, 5, 5, 5, 440, 10, 5, 3, 5, 3, 5, 3, 5,
	3, 5, 3, 5, 3, 5, 5, 5, 448, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6,
	455, 10, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 462, 10, 7, 3, 8, 3, 8,
	3, 8, 3, 8, 3, 8, 5, 8, 469, 10, 8, 3, 9, 3, 9, 3, 9, 7, 9, 474, 10, 9,
	12, 9, 14, 9, 477, 11, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 483, 10, 9, 7,
	9, 485, 10, 9, 12, 9, 14, 9, 488, 11, 9, 3, 9, 7, 9, 491, 10, 9, 12, 9,
	14, 9, 494, 11, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 5, 10, 501, 10, 10,
	3, 10, 3, 10, 5, 10, 505, 10, 10, 3, 11, 3, 11, 5, 11, 509, 10, 11, 3,
	12, 3, 12, 7, 12, 513, 10, 12, 12, 12, 14, 12, 516, 11, 12, 3, 12, 3, 12,
	6, 12, 520, 10, 12, 13, 12, 14, 12, 521, 3, 12, 7, 12, 525, 10, 12, 12,
	12, 14, 12, 528, 11, 12, 3, 13, 3, 13, 3, 13, 7, 13, 533, 10, 13, 12, 13,
	14, 13, 536, 11, 13, 3, 13, 5, 13, 539, 10, 13, 3, 14, 3, 14, 7, 14, 543,
	10, 14, 12, 14, 14, 14, 546, 11, 14, 3, 14, 6, 14, 549, 10, 14, 13, 14,
	14, 14, 550, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 7,
	16, 561, 10, 16, 12, 16, 14, 16, 564, 11, 16, 3, 16, 3, 16, 7, 16, 568,
	10, 16, 12, 16, 14, 16, 571, 11, 16, 3, 16, 3, 16, 7, 16, 575, 10, 16,
	12, 16, 14, 16, 578, 11, 16, 3, 16, 5, 16, 581, 10, 16, 3, 16, 7, 16, 584,
	10, 16, 12, 16, 14, 16, 587, 11, 16, 3, 16, 5, 16, 590, 10, 16, 3, 17,
	3, 17, 7, 17, 594, 10, 17, 12, 17, 14, 17, 597, 11, 17, 3, 17, 3, 17, 5,
	17, 601, 10, 17, 3, 18, 3, 18, 7, 18, 605, 10, 18, 12, 18, 14, 18, 608,
	11, 18, 3, 18, 3, 18, 5, 18, 612, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5,
	19, 618, 10, 19, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 624, 10, 20, 3, 21,
	3, 21, 5, 21, 628, 10, 21, 3, 22, 3, 22, 5, 22, 632, 10, 22, 3, 23, 3,
	23, 3, 23, 5, 23, 637, 10, 23, 3, 24, 3, 24, 5, 24, 641, 10, 24, 3, 24,
	3, 24, 3, 25, 3, 25, 6, 25, 647, 10, 25, 13, 25, 14, 25, 648, 3, 26, 3,
	26, 3, 26, 3, 26, 6, 26, 655, 10, 26, 13, 26, 14, 26, 656, 3, 27, 3, 27,
	3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 6, 27, 666, 10, 27, 13, 27, 14, 27,
	667, 3, 28, 3, 28, 5, 28, 672, 10, 28, 3, 29, 3, 29, 3, 30, 3, 30, 3, 31,
	3, 31, 3, 31, 2, 2, 32, 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, 2,
	85, 4, 2, 18, 18, 218, 218, 3, 2, 9, 10, 6, 2, 25, 25, 61, 61, 270, 270,
	272, 272, 3, 2, 15, 16, 4, 2, 24, 24, 28, 28, 4, 2, 26, 26, 270, 270, 3,
	2, 32, 33, 4, 2, 35, 35, 43, 43, 4, 2, 64, 64, 141, 141, 4, 2, 186, 186,
	255, 255, 4, 2, 39, 39, 271, 271, 4, 2, 40, 40, 44, 44, 3, 2, 45, 46, 3,
	2, 47, 48, 3, 2, 59, 60, 4, 2, 62, 62, 66, 66, 4, 2, 64, 64, 273, 273,
	5, 2, 272, 272, 275, 275, 279, 281, 3, 2, 274, 276, 8, 2, 37, 37, 103,
	103, 243, 243, 271, 271, 277, 277, 279, 279, 4, 2, 6, 6, 82, 82, 3, 2,
	76, 77, 6, 2, 31, 31, 52, 53, 73, 75, 257, 257, 4, 2, 78, 78, 84, 84, 3,
	2, 95, 96, 6, 2, 26, 26, 110, 110, 114, 114, 270, 270, 4, 2, 5, 5, 107,
	107, 5, 2, 31, 31, 52, 52, 75, 75, 4, 2, 110, 110, 114, 114, 5, 2, 272,
	272, 279, 279, 281, 281, 3, 2, 116, 117, 4, 2, 119, 119, 128, 128, 4, 2,
	118, 118, 123, 123, 3, 2, 126, 127, 4, 2, 124, 124, 129, 129, 3, 2, 130,
	131, 3, 2, 136, 137, 4, 2, 139, 139, 144, 144, 4, 2, 138, 138, 141, 141,
	3, 2, 152, 153, 3, 2, 155, 156, 3, 2, 157, 158, 3, 2, 159, 160, 3, 2, 162,
	163, 4, 2, 172, 172, 181, 181, 4, 2, 169, 169, 173, 173, 3, 2, 176, 177,
	3, 2, 178, 179, 3, 2, 182, 183, 3, 2, 188, 189, 4, 2, 193, 193, 195, 195,
	4, 2, 36, 36, 100, 101, 3, 2, 190, 191, 3, 2, 196, 197, 5, 2, 97, 97, 166,
	166, 214, 214, 3, 2, 199, 200, 3, 2, 202, 203, 4, 2, 208, 208, 210, 210,
	4, 2, 67, 67, 246, 246, 3, 2, 212, 213, 3, 2, 216, 217, 10, 2, 21, 21,
	25, 25, 87, 89, 91, 91, 98, 98, 258, 258, 276, 276, 280, 280, 4, 2, 220,
	220, 278, 278, 3, 2, 228, 229, 4, 2, 231, 231, 249, 249, 4, 2, 232, 232,
	279, 279, 3, 2, 237, 238, 3, 2, 244, 245, 3, 2, 250, 251, 4, 2, 70, 70,
	146, 146, 4, 2, 170, 171, 226, 227, 4, 2, 51, 51, 133, 133, 5, 2, 13, 13,
	208, 208, 246, 246, 3, 2, 260, 261, 4, 2, 262, 262, 265, 265, 6, 2, 25,
	25, 263, 263, 270, 270, 282, 282, 4, 2, 266, 266, 282, 282, 4, 2, 67, 67,
	230, 230, 3, 2, 267, 268, 4, 2, 71, 71, 201, 201, 3, 2, 240, 242, 3, 2,
	287, 288, 18, 2, 3, 19, 21, 26, 28, 53, 55, 56, 58, 62, 64, 78, 80, 89,
	91, 187, 189, 221, 223, 224, 226, 238, 243, 246, 248, 260, 262, 264, 266,
	282, 284, 284, 2, 893, 2, 76, 3, 2, 2, 2, 4, 81, 3, 2, 2, 2, 6, 91, 3,
	2, 2, 2, 8, 447, 3, 2, 2, 2, 10, 449, 3, 2, 2, 2, 12, 456, 3, 2, 2, 2,
	14, 463, 3, 2, 2, 2, 16, 470, 3, 2, 2, 2, 18, 500, 3, 2, 2, 2, 20, 508,
	3, 2, 2, 2, 22, 510, 3, 2, 2, 2, 24, 529, 3, 2, 2, 2, 26, 540, 3, 2, 2,
	2, 28, 554, 3, 2, 2, 2, 30, 558, 3, 2, 2, 2, 32, 591, 3, 2, 2, 2, 34, 602,
	3, 2, 2, 2, 36, 617, 3, 2, 2, 2, 38, 623, 3, 2, 2, 2, 40, 625, 3, 2, 2,
	2, 42, 629, 3, 2, 2, 2, 44, 633, 3, 2, 2, 2, 46, 638, 3, 2, 2, 2, 48, 646,
	3, 2, 2, 2, 50, 654, 3, 2, 2, 2, 52, 665, 3, 2, 2, 2, 54, 671, 3, 2, 2,
	2, 56, 673, 3, 2, 2, 2, 58, 675, 3, 2, 2, 2, 60, 677, 3, 2, 2, 2, 62, 75,
	5, 4, 3, 2, 63, 75, 5, 16, 9, 2, 64, 75, 5, 10, 6, 2, 65, 75, 5, 12, 7,
	2, 66, 75, 5, 14, 8, 2, 67, 75, 5, 28, 15, 2, 68, 75, 5, 24, 13, 2, 69,
	75, 5, 40, 21, 2, 70, 75, 5, 42, 22, 2, 71, 75, 5, 44, 23, 2, 72, 75, 5,
	52, 27, 2, 73, 75, 7, 291, 2, 2, 74, 62, 3, 2, 2, 2, 74, 63, 3, 2, 2, 2,
	74, 64, 3, 2, 2, 2, 74, 65, 3, 2, 2, 2, 74, 66, 3, 2, 2, 2, 74, 67, 3,
	2, 2, 2, 74, 68, 3, 2, 2, 2, 74, 69, 3, 2, 2, 2, 74, 70, 3, 2, 2, 2, 74,
	71, 3, 2, 2, 2, 74, 72, 3, 2, 2, 2, 74, 73, 3, 2, 2, 2, 75, 78, 3, 2, 2,
	2, 76, 74, 3, 2, 2, 2, 76, 77, 3, 2, 2, 2, 77, 79, 3, 2, 2, 2, 78, 76,
	3, 2, 2, 2, 79, 80, 7, 2, 2, 3, 80, 3, 3, 2, 2, 2, 81, 87, 9, 2, 2, 2,
	82, 84, 7, 284, 2, 2, 83, 82, 3, 2, 2, 2, 83, 84, 3, 2, 2, 2, 84, 85, 3,
	2, 2, 2, 85, 88, 5, 8, 5, 2, 86, 88, 5, 6, 4, 2, 87, 83, 3, 2, 2, 2, 87,
	86, 3, 2, 2, 2, 88, 89, 3, 2, 2, 2, 89, 87, 3, 2, 2, 2, 89, 90, 3, 2, 2,
	2, 90, 5, 3, 2, 2, 2, 91, 92, 7, 264, 2, 2, 92, 93, 7, 90, 2, 2, 93, 100,
	5, 8, 5, 2, 94, 96, 7, 284, 2, 2, 95, 94, 3, 2, 2, 2, 95, 96, 3, 2, 2,
	2, 96, 97, 3, 2, 2, 2, 97, 99, 5, 8, 5, 2, 98, 95, 3, 2, 2, 2, 99, 102,
	3, 2, 2, 2, 100, 98, 3, 2, 2, 2, 100, 101, 3, 2, 2, 2, 101, 103, 3, 2,
	2, 2, 102, 100, 3, 2, 2, 2, 103, 104, 7, 225, 2, 2, 104, 7, 3, 2, 2, 2,
	105, 448, 7, 3, 2, 2, 106, 448, 7, 4, 2, 2, 107, 448, 7, 8, 2, 2, 108,
	109, 9, 3, 2, 2, 109, 110, 7, 90, 2, 2, 110, 111, 9, 4, 2, 2, 111, 448,
	7, 225, 2, 2, 112, 448, 7, 12, 2, 2, 113, 448, 7, 14, 2, 2, 114, 115, 9,
	5, 2, 2, 115, 116, 7, 90, 2, 2, 116, 117, 5, 56, 29, 2, 117, 118, 7, 225,
	2, 2, 118, 448, 3, 2, 2, 2, 119, 448, 7, 19, 2, 2, 120, 125, 7, 20, 2,
	2, 121, 122, 7, 90, 2, 2, 122, 123, 5, 56, 29, 2, 123, 124, 7, 225, 2,
	2, 124, 126, 3, 2, 2, 2, 125, 121, 3, 2, 2, 2, 125, 126, 3, 2, 2, 2, 126,
	448, 3, 2, 2, 2, 127, 448, 7, 22, 2, 2, 128, 448, 7, 23, 2, 2, 129, 130,
	9, 6, 2, 2, 130, 131, 7, 90, 2, 2, 131, 132, 5, 56, 29, 2, 132, 133, 7,
	225, 2, 2, 133, 448, 3, 2, 2, 2, 134, 448, 9, 7, 2, 2, 135, 448, 7, 29,
	2, 2, 136, 448, 7, 30, 2, 2, 137, 138, 9, 8, 2, 2, 138, 139, 7, 90, 2,
	2, 139, 140, 5, 56, 29, 2, 140, 141, 7, 225, 2, 2, 141, 448, 3, 2, 2, 2,
	142, 143, 7, 34, 2, 2, 143, 144, 7, 90, 2, 2, 144, 145, 5, 56, 29, 2, 145,
	146, 7, 225, 2, 2, 146, 448, 3, 2, 2, 2, 147, 159, 9, 9, 2, 2, 148, 150,
	7, 90, 2, 2, 149, 151, 9, 10, 2, 2, 150, 149, 3, 2, 2, 2, 150, 151, 3,
	2, 2, 2, 151, 153, 3, 2, 2, 2, 152, 154, 7, 284, 2, 2, 153, 152, 3, 2,
	2, 2, 153, 154, 3, 2, 2, 2, 154, 156, 3, 2, 2, 2, 155, 157, 9, 11, 2, 2,
	156, 155, 3, 2, 2, 2, 156, 157, 3, 2, 2, 2, 157, 158, 3, 2, 2, 2, 158,
	160, 7, 225, 2, 2, 159, 148, 3, 2, 2, 2, 159, 160, 3, 2, 2, 2, 160, 448,
	3, 2, 2, 2, 161, 448, 7, 36, 2, 2, 162, 448, 9, 12, 2, 2, 163, 448, 7,
	38, 2, 2, 164, 448, 9, 13, 2, 2, 165, 448, 7, 42, 2, 2, 166, 448, 9, 14,
	2, 2, 167, 448, 9, 15, 2, 2, 168, 448, 7, 49, 2, 2, 169, 448, 7, 55, 2,
	2, 170, 448, 7, 58, 2, 2, 171, 448, 9, 16, 2, 2, 172, 448, 9, 17, 2, 2,
	173, 448, 7, 63, 2, 2, 174, 175, 9, 18, 2, 2, 175, 176, 7, 90, 2, 2, 176,
	179, 9, 19, 2, 2, 177, 178, 7, 284, 2, 2, 178, 180, 9, 19, 2, 2, 179, 177,
	3, 2, 2, 2, 179, 180, 3, 2, 2, 2, 180, 181, 3, 2, 2, 2, 181, 448, 7, 225,
	2, 2, 182, 183, 7, 65, 2, 2, 183, 184, 7, 90, 2, 2, 184, 187, 9, 20, 2,
	2, 185, 186, 7, 284, 2, 2, 186, 188, 9, 21, 2, 2, 187, 185, 3, 2, 2, 2,
	187, 188, 3, 2, 2, 2, 188, 189, 3, 2, 2, 2, 189, 448, 7, 225, 2, 2, 190,
	448, 7, 68, 2, 2, 191, 448, 7, 69, 2, 2, 192, 193, 7, 72, 2, 2, 193, 194,
	7, 90, 2, 2, 194, 195, 9, 22, 2, 2, 195, 448, 7, 225, 2, 2, 196, 197, 9,
	23, 2, 2, 197, 198, 7, 90, 2, 2, 198, 199, 9, 24, 2, 2, 199, 448, 7, 225,
	2, 2, 200, 448, 7, 79, 2, 2, 201, 448, 7, 80, 2, 2, 202, 448, 7, 81, 2,
	2, 203, 448, 7, 83, 2, 2, 204, 205, 9, 25, 2, 2, 205, 206, 7, 90, 2, 2,
	206, 207, 5, 56, 29, 2, 207, 208, 7, 225, 2, 2, 208, 448, 3, 2, 2, 2, 209,
	448, 7, 85, 2, 2, 210, 448, 7, 86, 2, 2, 211, 448, 7, 92, 2, 2, 212, 213,
	7, 93, 2, 2, 213, 214, 7, 90, 2, 2, 214, 215, 5, 56, 29, 2, 215, 216, 7,
	284, 2, 2, 216, 219, 5, 56, 29, 2, 217, 218, 7, 284, 2, 2, 218, 220, 5,
	56, 29, 2, 219, 217, 3, 2, 2, 2, 219, 220, 3, 2, 2, 2, 220, 221, 3, 2,
	2, 2, 221, 222, 7, 225, 2, 2, 222, 448, 3, 2, 2, 2, 223, 227, 9, 26, 2,
	2, 224, 225, 7, 90, 2, 2, 225, 226, 9, 27, 2, 2, 226, 228, 7, 225, 2, 2,
	227, 224, 3, 2, 2, 2, 227, 228, 3, 2, 2, 2, 228, 448, 3, 2, 2, 2, 229,
	233, 7, 99, 2, 2, 230, 231, 7, 90, 2, 2, 231, 232, 9, 28, 2, 2, 232, 234,
	7, 225, 2, 2, 233, 230, 3, 2, 2, 2, 233, 234, 3, 2, 2, 2, 234, 448, 3,
	2, 2, 2, 235, 236, 7, 102, 2, 2, 236, 237, 7, 90, 2, 2, 237, 238, 9, 29,
	2, 2, 238, 448, 7, 225, 2, 2, 239, 448, 7, 105, 2, 2, 240, 448, 7, 106,
	2, 2, 241, 448, 7, 108, 2, 2, 242, 448, 7, 109, 2, 2, 243, 448, 7, 111,
	2, 2, 244, 448, 7, 112, 2, 2, 245, 448, 7, 113, 2, 2, 246, 250, 9, 30,
	2, 2, 247, 248, 7, 90, 2, 2, 248, 249, 9, 31, 2, 2, 249, 251, 7, 225, 2,
	2, 250, 247, 3, 2, 2, 2, 250, 251, 3, 2, 2, 2, 251, 448, 3, 2, 2, 2, 252,
	448, 7, 115, 2, 2, 253, 448, 9, 32, 2, 2, 254, 448, 9, 33, 2, 2, 255, 448,
	7, 120, 2, 2, 256, 448, 7, 122, 2, 2, 257, 448, 9, 34, 2, 2, 258, 448,
	7, 125, 2, 2, 259, 448, 7, 121, 2, 2, 260, 448, 9, 35, 2, 2, 261, 448,
	9, 36, 2, 2, 262, 448, 9, 37, 2, 2, 263, 448, 7, 132, 2, 2, 264, 448, 7,
	134, 2, 2, 265, 448, 7, 135, 2, 2, 266, 448, 9, 38, 2, 2, 267, 448, 9,
	39, 2, 2, 268, 448, 7, 140, 2, 2, 269, 448, 9, 40, 2, 2, 270, 448, 7, 142,
	2, 2, 271, 448, 7, 143, 2, 2, 272, 448, 7, 145, 2, 2, 273, 448, 7, 147,
	2, 2, 274, 448, 7, 148, 2, 2, 275, 448, 7, 149, 2, 2, 276, 448, 7, 150,
	2, 2, 277, 448, 7, 151, 2, 2, 278, 448, 9, 41, 2, 2, 279, 448, 7, 154,
	2, 2, 280, 448, 9, 42, 2, 2, 281, 448, 9, 43, 2, 2, 282, 448, 9, 44, 2,
	2, 283, 448, 7, 161, 2, 2, 284, 448, 9, 45, 2, 2, 285, 448, 7, 164, 2,
	2, 286, 448, 7, 165, 2, 2, 287, 448, 7, 167, 2, 2, 288, 448, 7, 168, 2,
	2, 289, 448, 9, 46, 2, 2, 290, 448, 9, 47, 2, 2, 291, 448, 7, 174, 2, 2,
	292, 448, 7, 175, 2, 2, 293, 448, 9, 48, 2, 2, 294, 448, 9, 49, 2, 2, 295,
	448, 7, 180, 2, 2, 296, 448, 9, 50, 2, 2, 297, 448, 7, 184, 2, 2, 298,
	448, 7, 185, 2, 2, 299, 448, 7, 187, 2, 2, 300, 448, 9, 51, 2, 2, 301,
	448, 7, 194, 2, 2, 302, 303, 9, 52, 2, 2, 303, 304, 7, 90, 2, 2, 304, 305,
	9, 53, 2, 2, 305, 448, 7, 225, 2, 2, 306, 448, 7, 187, 2, 2, 307, 448,
	9, 54, 2, 2, 308, 448, 7, 192, 2, 2, 309, 448, 9, 55, 2, 2, 310, 311, 7,
	198, 2, 2, 311, 312, 7, 90, 2, 2, 312, 313, 9, 56, 2, 2, 313, 448, 7, 225,
	2, 2, 314, 448, 9, 57, 2, 2, 315, 448, 9, 58, 2, 2, 316, 317, 7, 206, 2,
	2, 317, 318, 7, 90, 2, 2, 318, 319, 5, 56, 29, 2, 319, 320, 7, 284, 2,
	2, 320, 323, 5, 56, 29, 2, 321, 322, 7, 284, 2, 2, 322, 324, 5, 56, 29,
	2, 323, 321, 3, 2, 2, 2, 323, 324, 3, 2, 2, 2, 324, 325, 3, 2, 2, 2, 325,
	326, 7, 225, 2, 2, 326, 448, 3, 2, 2, 2, 327, 328, 7, 207, 2, 2, 328, 329,
	7, 90, 2, 2, 329, 330, 5, 56, 29, 2, 330, 331, 7, 284, 2, 2, 331, 332,
	5, 56, 29, 2, 332, 333, 7, 225, 2, 2, 333, 448, 3, 2, 2, 2, 334, 338, 9,
	59, 2, 2, 335, 336, 7, 90, 2, 2, 336, 337, 9, 60, 2, 2, 337, 339, 7, 225,
	2, 2, 338, 335, 3, 2, 2, 2, 338, 339, 3, 2, 2, 2, 339, 448, 3, 2, 2, 2,
	340, 448, 7, 209, 2, 2, 341, 448, 7, 211, 2, 2, 342, 448, 7, 205, 2, 2,
	343, 344, 9, 61, 2, 2, 344, 345, 7, 90, 2, 2, 345, 346, 5, 54, 28, 2, 346,
	347, 7, 225, 2, 2, 347, 448, 3, 2, 2, 2, 348, 349, 9, 62, 2, 2, 349, 350,
	7, 90, 2, 2, 350, 351, 9, 63, 2, 2, 351, 448, 7, 225, 2, 2, 352, 448, 7,
	219, 2, 2, 353, 448, 9, 64, 2, 2, 354, 448, 7, 221, 2, 2, 355, 356, 7,
	224, 2, 2, 356, 360, 7, 90, 2, 2, 357, 361, 7, 7, 2, 2, 358, 361, 7, 11,
	2, 2, 359, 361, 5, 56, 29, 2, 360, 357, 3, 2, 2, 2, 360, 358, 3, 2, 2,
	2, 360, 359, 3, 2, 2, 2, 361, 362, 3, 2, 2, 2, 362, 448, 7, 225, 2, 2,
	363, 370, 9, 65, 2, 2, 364, 365, 7, 90, 2, 2, 365, 366, 5, 56, 29, 2, 366,
	367, 7, 284, 2, 2, 367, 368, 5, 56, 29, 2, 368, 369, 7, 225, 2, 2, 369,
	371, 3, 2, 2, 2, 370, 364, 3, 2, 2, 2, 370, 371, 3, 2, 2, 2, 371, 448,
	3, 2, 2, 2, 372, 373, 9, 66, 2, 2, 373, 376, 7, 90, 2, 2, 374, 377, 7,
	94, 2, 2, 375, 377, 5, 56, 29, 2, 376, 374, 3, 2, 2, 2, 376, 375, 3, 2,
	2, 2, 377, 378, 3, 2, 2, 2, 378, 448, 7, 225, 2, 2, 379, 448, 9, 67, 2,
	2, 380, 448, 7, 233, 2, 2, 381, 382, 7, 234, 2, 2, 382, 383, 7, 90, 2,
	2, 383, 384, 5, 56, 29, 2, 384, 385, 7, 225, 2, 2, 385, 448, 3, 2, 2, 2,
	386, 448, 7, 235, 2, 2, 387, 392, 7, 236, 2, 2, 388, 389, 7, 90, 2, 2,
	389, 390, 5, 56, 29, 2, 390, 391, 7, 225, 2, 2, 391, 393, 3, 2, 2, 2, 392,
	388, 3, 2, 2, 2, 392, 393, 3, 2, 2, 2, 393, 448, 3, 2, 2, 2, 394, 448,
	9, 68, 2, 2, 395, 448, 9, 69, 2, 2, 396, 448, 7, 248, 2, 2, 397, 448, 9,
	70, 2, 2, 398, 416, 7, 252, 2, 2, 399, 401, 7, 90, 2, 2, 400, 402, 9, 71,
	2, 2, 401, 400, 3, 2, 2, 2, 401, 402, 3, 2, 2, 2, 402, 404, 3, 2, 2, 2,
	403, 405, 7, 284, 2, 2, 404, 403, 3, 2, 2, 2, 404, 405, 3, 2, 2, 2, 405,
	407, 3, 2, 2, 2, 406, 408, 9, 72, 2, 2, 407, 406, 3, 2, 2, 2, 407, 408,
	3, 2, 2, 2, 408, 410, 3, 2, 2, 2, 409, 411, 7, 284, 2, 2, 410, 409, 3,
	2, 2, 2, 410, 411, 3, 2, 2, 2, 411, 413, 3, 2, 2, 2, 412, 414, 9, 73, 2,
	2, 413, 412, 3, 2, 2, 2, 413, 414, 3, 2, 2, 2, 414, 415, 3, 2, 2, 2, 415,
	417, 7, 225, 2, 2, 416, 399, 3, 2, 2, 2, 416, 417, 3, 2, 2, 2, 417, 448,
	3, 2, 2, 2, 418, 448, 7, 253, 2, 2, 419, 420, 7, 256, 2, 2, 420, 421, 7,
	90, 2, 2, 421, 422, 9, 74, 2, 2, 422, 448, 7, 225, 2, 2, 423, 448, 7, 259,
	2, 2, 424, 425, 9, 75, 2, 2, 425, 426, 7, 90, 2, 2, 426, 427, 5, 54, 28,
	2, 427, 428, 7, 225, 2, 2, 428, 448, 3, 2, 2, 2, 429, 430, 9, 76, 2, 2,
	430, 431, 7, 90, 2, 2, 431, 432, 9, 77, 2, 2, 432, 448, 7, 225, 2, 2, 433,
	439, 9, 78, 2, 2, 434, 436, 7, 90, 2, 2, 435, 437, 9, 79, 2, 2, 436, 435,
	3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 440, 7, 225,
	2, 2, 439, 434, 3, 2, 2, 2, 439, 440, 3, 2, 2, 2, 440, 448, 3, 2, 2, 2,
	441, 442, 9, 80, 2, 2, 442, 443, 7, 90, 2, 2, 443, 444, 5, 56, 29, 2, 444,
	445, 7, 225, 2, 2, 445, 448, 3, 2, 2, 2, 446, 448, 7, 269, 2, 2, 447, 105,
	3, 2, 2, 2, 447, 106, 3, 2, 2, 2, 447, 107, 3, 2, 2, 2, 447, 108, 3, 2,
	2, 2, 447, 112, 3, 2, 2, 2, 447, 113, 3, 2, 2, 2, 447, 114, 3, 2, 2, 2,
	447, 119, 3, 2, 2, 2, 447, 120, 3, 2, 2, 2, 447, 127, 3, 2, 2, 2, 447,
	128, 3, 2, 2, 2, 447, 129, 3, 2, 2, 2, 447, 134, 3, 2, 2, 2, 447, 135,
	3, 2, 2, 2, 447, 136, 3, 2, 2, 2, 447, 137, 3, 2, 2, 2, 447, 142, 3, 2,
	2, 2, 447, 147, 3, 2, 2, 2, 447, 161, 3, 2, 2, 2, 447, 162, 3, 2, 2, 2,
	447, 163, 3, 2, 2, 2, 447, 164, 3, 2, 2, 2, 447, 165, 3, 2, 2, 2, 447,
	166, 3, 2, 2, 2, 447, 167, 3, 2, 2, 2, 447, 168, 3, 2, 2, 2, 447, 169,
	3, 2, 2, 2, 447, 170, 3, 2, 2, 2, 447, 171, 3, 2, 2, 2, 447, 172, 3, 2,
	2, 2, 447, 173, 3, 2, 2, 2, 447, 174, 3, 2, 2, 2, 447, 182, 3, 2, 2, 2,
	447, 190, 3, 2, 2, 2, 447, 191, 3, 2, 2, 2, 447, 192, 3, 2, 2, 2, 447,
	196, 3, 2, 2, 2, 447, 200, 3, 2, 2, 2, 447, 201, 3, 2, 2, 2, 447, 202,
	3, 2, 2, 2, 447, 203, 3, 2, 2, 2, 447, 204, 3, 2, 2, 2, 447, 209, 3, 2,
	2, 2, 447, 210, 3, 2, 2, 2, 447, 211, 3, 2, 2, 2, 447, 212, 3, 2, 2, 2,
	447, 223, 3, 2, 2, 2, 447, 229, 3, 2, 2, 2, 447, 235, 3, 2, 2, 2, 447,
	239, 3, 2, 2, 2, 447, 240, 3, 2, 2, 2, 447, 241, 3, 2, 2, 2, 447, 242,
	3, 2, 2, 2, 447, 243, 3, 2, 2, 2, 447, 244, 3, 2, 2, 2, 447, 245, 3, 2,
	2, 2, 447, 246, 3, 2, 2, 2, 447, 252, 3, 2, 2, 2, 447, 253, 3, 2, 2, 2,
	447, 254, 3, 2, 2, 2, 447, 255, 3, 2, 2, 2, 447, 256, 3, 2, 2, 2, 447,
	257, 3, 2, 2, 2, 447, 258, 3, 2, 2, 2, 447, 259, 3, 2, 2, 2, 447, 260,
	3, 2, 2, 2, 447, 261, 3, 2, 2, 2, 447, 262, 3, 2, 2, 2, 447, 263, 3, 2,
	2, 2, 447, 264, 3, 2, 2, 2, 447, 265, 3, 2, 2, 2, 447, 266, 3, 2, 2, 2,
	447, 267, 3, 2, 2, 2, 447, 268, 3, 2, 2, 2, 447, 269, 3, 2, 2, 2, 447,
	270, 3, 2, 2, 2, 447, 271, 3, 2, 2, 2, 447, 272, 3, 2, 2, 2, 447, 273,
	3, 2, 2, 2, 447, 274, 3, 2, 2, 2, 447, 275, 3, 2, 2, 2, 447, 276, 3, 2,
	2, 2, 447, 277, 3, 2, 2, 2, 447, 278, 3, 2, 2, 2, 447, 279, 3, 2, 2, 2,
	447, 280, 3, 2, 2, 2, 447, 281, 3, 2, 2, 2, 447, 282, 3, 2, 2, 2, 447,
	283, 3, 2, 2, 2, 447, 284, 3, 2, 2, 2, 447, 285, 3, 2, 2, 2, 447, 286,
	3, 2, 2, 2, 447, 287, 3, 2, 2, 2, 447, 288, 3, 2, 2, 2, 447, 289, 3, 2,
	2, 2, 447, 290, 3, 2, 2, 2, 447, 291, 3, 2, 2, 2, 447, 292, 3, 2, 2, 2,
	447, 293, 3, 2, 2, 2, 447, 294, 3, 2, 2, 2, 447, 295, 3, 2, 2, 2, 447,
	296, 3, 2, 2, 2, 447, 297, 3, 2, 2, 2, 447, 298, 3, 2, 2, 2, 447, 299,
	3, 2, 2, 2, 447, 300, 3, 2, 2, 2, 447, 301, 3, 2, 2, 2, 447, 302, 3, 2,
	2, 2, 447, 306, 3, 2, 2, 2, 447, 307, 3, 2, 2, 2, 447, 308, 3, 2, 2, 2,
	447, 309, 3, 2, 2, 2, 447, 310, 3, 2, 2, 2, 447, 314, 3, 2, 2, 2, 447,
	315, 3, 2, 2, 2, 447, 316, 3, 2, 2, 2, 447, 327, 3, 2, 2, 2, 447, 334,
	3, 2, 2, 2, 447, 340, 3, 2, 2, 2, 447, 341, 3, 2, 2, 2, 447, 342, 3, 2,
	2, 2, 447, 343, 3, 2, 2, 2, 447, 348, 3, 2, 2, 2, 447, 352, 3, 2, 2, 2,
	447, 353, 3, 2, 2, 2, 447, 354, 3, 2, 2, 2, 447, 355, 3, 2, 2, 2, 447,
	363, 3, 2, 2, 2, 447, 372, 3, 2, 2, 2, 447, 379, 3, 2, 2, 2, 447, 380,
	3, 2, 2, 2, 447, 381, 3, 2, 2, 2, 447, 386, 3, 2, 2, 2, 447, 387, 3, 2,
	2, 2, 447, 394, 3, 2, 2, 2, 447, 395, 3, 2, 2, 2, 447, 396, 3, 2, 2, 2,
	447, 397, 3, 2, 2, 2, 447, 398, 3, 2, 2, 2, 447, 418, 3, 2, 2, 2, 447,
	419, 3, 2, 2, 2, 447, 423, 3, 2, 2, 2, 447, 424, 3, 2, 2, 2, 447, 429,
	3, 2, 2, 2, 447, 433, 3, 2, 2, 2, 447, 441, 3, 2, 2, 2, 447, 446, 3, 2,
	2, 2, 448, 9, 3, 2, 2, 2, 449, 450, 7, 57, 2, 2, 450, 451, 7, 20, 2, 2,
	451, 452, 5, 48, 25, 2, 452, 454, 7, 54, 2, 2, 453, 455, 7, 285, 2, 2,
	454, 453, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 11, 3, 2, 2, 2, 456, 457,
	7, 57, 2, 2, 457, 458, 7, 236, 2, 2, 458, 459, 5, 50, 26, 2, 459, 461,
	7, 54, 2, 2, 460, 462, 7, 285, 2, 2, 461, 460, 3, 2, 2, 2, 461, 462, 3,
	2, 2, 2, 462, 13, 3, 2, 2, 2, 463, 464, 7, 57, 2, 2, 464, 465, 7, 239,
	2, 2, 465, 466, 5, 48, 25, 2, 466, 468, 7, 54, 2, 2, 467, 469, 7, 285,
	2, 2, 468, 467, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 15, 3, 2, 2, 2,
	470, 471, 7, 27, 2, 2, 471, 486, 5, 18, 10, 2, 472, 474, 7, 291, 2, 2,
	473, 472, 3, 2, 2, 2, 474, 477, 3, 2, 2, 2, 475, 473, 3, 2, 2, 2, 475,
	476, 3, 2, 2, 2, 476, 482, 3, 2, 2, 2, 477, 475, 3, 2, 2, 2, 478, 483,
	5, 32, 17, 2, 479, 483, 5, 34, 18, 2, 480, 483, 5, 22, 12, 2, 481, 483,
	7, 247, 2, 2, 482, 478, 3, 2, 2, 2, 482, 479, 3, 2, 2, 2, 482, 480, 3,
	2, 2, 2, 482, 481, 3, 2, 2, 2, 483, 485, 3, 2, 2, 2, 484, 475, 3, 2, 2,
	2, 485, 488, 3, 2, 2, 2, 486, 484, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487,
	492, 3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 489, 491, 7, 291, 2, 2, 490, 489,
	3, 2, 2, 2, 491, 494, 3, 2, 2, 2, 492, 490, 3, 2, 2, 2, 492, 493, 3, 2,
	2, 2, 493, 495, 3, 2, 2, 2, 494, 492, 3, 2, 2, 2, 495, 496, 7, 285, 2,
	2, 496, 17, 3, 2, 2, 2, 497, 501, 5, 56, 29, 2, 498, 501, 5, 54, 28, 2,
	499, 501, 5, 58, 30, 2, 500, 497, 3, 2, 2, 2, 500, 498, 3, 2, 2, 2, 500,
	499, 3, 2, 2, 2, 501, 504, 3, 2, 2, 2, 502, 503, 9, 81, 2, 2, 503, 505,
	5, 20, 11, 2, 504, 502, 3, 2, 2, 2, 504, 505, 3, 2, 2, 2, 505, 19, 3, 2,
	2, 2, 506, 509, 5, 56, 29, 2, 507, 509, 5, 54, 28, 2, 508, 506, 3, 2, 2,
	2, 508, 507, 3, 2, 2, 2, 509, 21, 3, 2, 2, 2, 510, 514, 7, 223, 2, 2, 511,
	513, 7, 291, 2, 2, 512, 511, 3, 2, 2, 2, 513, 516, 3, 2, 2, 2, 514, 512,
	3, 2, 2, 2, 514, 515, 3, 2, 2, 2, 515, 517, 3, 2, 2, 2, 516, 514, 3, 2,
	2, 2, 517, 526, 5, 30, 16, 2, 518, 520, 7, 291, 2, 2, 519, 518, 3, 2, 2,
	2, 520, 521, 3, 2, 2, 2, 521, 519, 3, 2, 2, 2, 521, 522, 3, 2, 2, 2, 522,
	523, 3, 2, 2, 2, 523, 525, 5, 30, 16, 2, 524, 519, 3, 2, 2, 2, 525, 528,
	3, 2, 2, 2, 526, 524, 3, 2, 2, 2, 526, 527, 3, 2, 2, 2, 527, 23, 3, 2,
	2, 2, 528, 526, 3, 2, 2, 2, 529, 534, 5, 26, 14, 2, 530, 533, 5, 16, 9,
	2, 531, 533, 5, 48, 25, 2, 532, 530, 3, 2, 2, 2, 532, 531, 3, 2, 2, 2,
	533, 536, 3, 2, 2, 2, 534, 532, 3, 2, 2, 2, 534, 535, 3, 2, 2, 2, 535,
	538, 3, 2, 2, 2, 536, 534, 3, 2, 2, 2, 537, 539, 5, 28, 15, 2, 538, 537,
	3, 2, 2, 2, 538, 539, 3, 2, 2, 2, 539, 25, 3, 2, 2, 2, 540, 548, 7, 222,
	2, 2, 541, 543, 7, 291, 2, 2, 542, 541, 3, 2, 2, 2, 543, 546, 3, 2, 2,
	2, 544, 542, 3, 2, 2, 2, 544, 545, 3, 2, 2, 2, 545, 547, 3, 2, 2, 2, 546,
	544, 3, 2, 2, 2, 547, 549, 5, 30, 16, 2, 548, 544, 3, 2, 2, 2, 549, 550,
	3, 2, 2, 2, 550, 548, 3, 2, 2, 2, 550, 551, 3, 2, 2, 2, 551, 552, 3, 2,
	2, 2, 552, 553, 7, 285, 2, 2, 553, 27, 3, 2, 2, 2, 554, 555, 7, 222, 2,
	2, 555, 556, 7, 202, 2, 2, 556, 557, 7, 285, 2, 2, 557, 29, 3, 2, 2, 2,
	558, 562, 5, 36, 19, 2, 559, 561, 7, 291, 2, 2, 560, 559, 3, 2, 2, 2, 561,
	564, 3, 2, 2, 2, 562, 560, 3, 2, 2, 2, 562, 563, 3, 2, 2, 2, 563, 565,
	3, 2, 2, 2, 564, 562, 3, 2, 2, 2, 565, 569, 7, 17, 2, 2, 566, 568, 7, 291,
	2, 2, 567, 566, 3, 2, 2, 2, 568, 571, 3, 2, 2, 2, 569, 567, 3, 2, 2, 2,
	569, 570, 3, 2, 2, 2, 570, 572, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 572,
	580, 5, 38, 20, 2, 573, 575, 7, 291, 2, 2, 574, 573, 3, 2, 2, 2, 575, 578,
	3, 2, 2, 2, 576, 574, 3, 2, 2, 2, 576, 577, 3, 2, 2, 2, 577, 579, 3, 2,
	2, 2, 578, 576, 3, 2, 2, 2, 579, 581, 5, 32, 17, 2, 580, 576, 3, 2, 2,
	2, 580, 581, 3, 2, 2, 2, 581, 589, 3, 2, 2, 2, 582, 584, 7, 291, 2, 2,
	583, 582, 3, 2, 2, 2, 584, 587, 3, 2, 2, 2, 585, 583, 3, 2, 2, 2, 585,
	586, 3, 2, 2, 2, 586, 588, 3, 2, 2, 2, 587, 585, 3, 2, 2, 2, 588, 590,
	5, 34, 18, 2, 589, 585, 3, 2, 2, 2, 589, 590, 3, 2, 2, 2, 590, 31, 3, 2,
	2, 2, 591, 595, 9, 81, 2, 2, 592, 594, 7, 291, 2, 2, 593, 592, 3, 2, 2,
	2, 594, 597, 3, 2, 2, 2, 595, 593, 3, 2, 2, 2, 595, 596, 3, 2, 2, 2, 596,
	600, 3, 2, 2, 2, 597, 595, 3, 2, 2, 2, 598, 601, 5, 56, 29, 2, 599, 601,
	5, 54, 28, 2, 600, 598, 3, 2, 2, 2, 600, 599, 3, 2, 2, 2, 601, 33, 3, 2,
	2, 2, 602, 606, 7, 204, 2, 2, 603, 605, 7, 291, 2, 2, 604, 603, 3, 2, 2,
	2, 605, 608, 3, 2, 2, 2, 606, 604, 3, 2, 2, 2, 606, 607, 3, 2, 2, 2, 607,
	611, 3, 2, 2, 2, 608, 606, 3, 2, 2, 2, 609, 612, 5, 56, 29, 2, 610, 612,
	5, 54, 28, 2, 611, 609, 3, 2, 2, 2, 611, 610, 3, 2, 2, 2, 612, 35, 3, 2,
	2, 2, 613, 618, 5, 56, 29, 2, 614, 618, 5, 54, 28, 2, 615, 618, 5, 46,
	24, 2, 616, 618, 5, 52, 27, 2, 617, 613, 3, 2, 2, 2, 617, 614, 3, 2, 2,
	2, 617, 615, 3, 2, 2, 2, 617, 616, 3, 2, 2, 2, 618, 37, 3, 2, 2, 2, 619,
	624, 5, 56, 29, 2, 620, 624, 5, 54, 28, 2, 621, 624, 5, 46, 24, 2, 622,
	624, 5, 52, 27, 2, 623, 619, 3, 2, 2, 2, 623, 620, 3, 2, 2, 2, 623, 621,
	3, 2, 2, 2, 623, 622, 3, 2, 2, 2, 624, 39, 3, 2, 2, 2, 625, 627, 7, 50,
	2, 2, 626, 628, 7, 285, 2, 2, 627, 626, 3, 2, 2, 2, 627, 628, 3, 2, 2,
	2, 628, 41, 3, 2, 2, 2, 629, 631, 9, 82, 2, 2, 630, 632, 7, 285, 2, 2,
	631, 630, 3, 2, 2, 2, 631, 632, 3, 2, 2, 2, 632, 43, 3, 2, 2, 2, 633, 634,
	7, 254, 2, 2, 634, 636, 5, 56, 29, 2, 635, 637, 7, 285, 2, 2, 636, 635,
	3, 2, 2, 2, 636, 637, 3, 2, 2, 2, 637, 45, 3, 2, 2, 2, 638, 640, 7, 286,
	2, 2, 639, 641, 5, 48, 25, 2, 640, 639, 3, 2, 2, 2, 640, 641, 3, 2, 2,
	2, 641, 642, 3, 2, 2, 2, 642, 643, 7, 286, 2, 2, 643, 47, 3, 2, 2, 2, 644,
	647, 5, 52, 27, 2, 645, 647, 7, 291, 2, 2, 646, 644, 3, 2, 2, 2, 646, 645,
	3, 2, 2, 2, 647, 648, 3, 2, 2, 2, 648, 646, 3, 2, 2, 2, 648, 649, 3, 2,
	2, 2, 649, 49, 3, 2, 2, 2, 650, 655, 5, 52, 27, 2, 651, 655, 7, 27, 2,
	2, 652, 655, 7, 222, 2, 2, 653, 655, 7, 291, 2, 2, 654, 650, 3, 2, 2, 2,
	654, 651, 3, 2, 2, 2, 654, 652, 3, 2, 2, 2, 654, 653, 3, 2, 2, 2, 655,
	656, 3, 2, 2, 2, 656, 654, 3, 2, 2, 2, 656, 657, 3, 2, 2, 2, 657, 51, 3,
	2, 2, 2, 658, 666, 5, 54, 28, 2, 659, 666, 5, 56, 29, 2, 660, 666, 5, 58,
	30, 2, 661, 666, 7, 294, 2, 2, 662, 666, 7, 285, 2, 2, 663, 666, 7, 90,
	2, 2, 664, 666, 7, 225, 2, 2, 665, 658, 3, 2, 2, 2, 665, 659, 3, 2, 2,
	2, 665, 660, 3, 2, 2, 2, 665, 661, 3, 2, 2, 2, 665, 662, 3, 2, 2, 2, 665,
	663, 3, 2, 2, 2, 665, 664, 3, 2, 2, 2, 666, 667, 3, 2, 2, 2, 667, 665,
	3, 2, 2, 2, 667, 668, 3, 2, 2, 2, 668, 53, 3, 2, 2, 2, 669, 672, 7, 289,
	2, 2, 670, 672, 5, 60, 31, 2, 671, 669, 3, 2, 2, 2, 671, 670, 3, 2, 2,
	2, 672, 55, 3, 2, 2, 2, 673, 674, 9, 83, 2, 2, 674, 57, 3, 2, 2, 2, 675,
	676, 7, 290, 2, 2, 676, 59, 3, 2, 2, 2, 677, 678, 9, 84, 2, 2, 678, 61,
	3, 2, 2, 2, 76, 74, 76, 83, 87, 89, 95, 100, 125, 150, 153, 156, 159, 179,
	187, 219, 227, 233, 250, 323, 338, 360, 370, 376, 392, 401, 404, 407, 410,
	413, 416, 436, 439, 447, 454, 461, 468, 475, 482, 486, 492, 500, 504, 508,
	514, 521, 526, 532, 534, 538, 544, 550, 562, 569, 576, 580, 585, 589, 595,
	600, 606, 611, 617, 623, 627, 631, 636, 640, 646, 648, 654, 656, 665, 667,
	671,
}
var deserializer = antlr.NewATNDeserializer(nil)
var deserializedATN = deserializer.DeserializeFromUInt16(parserATN)

var literalNames = []string{
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'('",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "')'", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "'*>'", "','", "'.'",
	"'=='",
}
var symbolicNames = []string{
	"", "ADATA", "ADV", "ALIAS", "ANSI", "ANY", "APOST", "AR", "ARITH", "AUTO",
	"AWO", "BIN", "BLOCK0", "BUF", "BUFSIZE", "BY", "CBL", "CBLCARD", "CICS",
	"CO", "COBOL2", "COBOL3", "CODEPAGE", "COMPAT", "COMPILE", "COPY", "CP",
	"CPP", "CPSM", "CS", "CURR", "CURRENCY", "DATA", "DATEPROC", "DBCS", "DD",
	"DEBUG", "DECK", "DIAGTRUNC", "DLI", "DLL", "DP", "DTR", "DU", "DUMP",
	"DYN", "DYNAM", "EDF", "EJECT", "EJPD", "EN", "ENGLISH", "END_EXEC", "EPILOG",
	"EXCI", "EXEC", "EXIT", "EXP", "EXPORTALL", "EXTEND", "FASTSRT", "FEPI",
	"FLAG", "FLAGSTD", "FSRT", "FULL", "GDS", "GRAPHIC", "HOOK", "IN", "INTDATE",
	"JA", "JP", "KA", "LANG", "LANGUAGE", "LC", "LEASM", "LENGTH", "LIB", "LILIAN",
	"LIN", "LINECOUNT", "LINKAGE", "LIST", "LM", "LONGMIXED", "LONGUPPER",
	"LPARENCHAR", "LU", "MAP", "MARGINS", "MAX", "MD", "MDECK", "MIG", "MIXED",
	"NAME", "NAT", "NATIONAL", "NATLANG", "NN", "NO", "NOADATA", "NOADV", "NOALIAS",
	"NOAWO", "NOBLOCK0", "NOC", "NOCBLCARD", "NOCICS", "NOCMPR2", "NOCOMPILE",
	"NOCPSM", "NOCURR", "NOCURRENCY", "NOD", "NODATEPROC", "NODBCS", "NODE",
	"NODEBUG", "NODECK", "NODIAGTRUNC", "NODLL", "NODU", "NODUMP", "NODP",
	"NODTR", "NODYN", "NODYNAM", "NOEDF", "NOEJPD", "NOEPILOG", "NOEXIT", "NOEXP",
	"NOEXPORTALL", "NOF", "NOFASTSRT", "NOFEPI", "NOFLAG", "NOFLAGMIG", "NOFLAGSTD",
	"NOFSRT", "NOGRAPHIC", "NOHOOK", "NOLENGTH", "NOLIB", "NOLINKAGE", "NOLIST",
	"NOMAP", "NOMD", "NOMDECK", "NONAME", "NONUM", "NONUMBER", "NOOBJ", "NOOBJECT",
	"NOOFF", "NOOFFSET", "NOOPSEQUENCE", "NOOPT", "NOOPTIMIZE", "NOOPTIONS",
	"NOP", "NOPFD", "NOPROLOG", "NORENT", "NOS", "NOSEP", "NOSEPARATE", "NOSEQ",
	"NOSOURCE", "NOSPIE", "NOSQL", "NOSQLC", "NOSQLCCSID", "NOSSR", "NOSSRANGE",
	"NOSTDTRUNC", "NOSEQUENCE", "NOTERM", "NOTERMINAL", "NOTEST", "NOTHREAD",
	"NOTRIG", "NOVBREF", "NOWD", "NOWORD", "NOX", "NOXREF", "NOZWB", "NS",
	"NSEQ", "NSYMBOL", "NUM", "NUMBER", "NUMPROC", "OBJ", "OBJECT", "OF", "OFF",
	"OFFSET", "ON", "OP", "OPMARGINS", "OPSEQUENCE", "OPT", "OPTFILE", "OPTIMIZE",
	"OPTIONS", "OUT", "OUTDD", "PFD", "PPTDBG", "PGMN", "PGMNAME", "PROCESS",
	"PROLOG", "QUOTE", "RENT", "REPLACE", "REPLACING", "RMODE", "RPARENCHAR",
	"SEP", "SEPARATE", "SEQ", "SEQUENCE", "SHORT", "SIZE", "SOURCE", "SP",
	"SPACE", "SPIE", "SQL", "SQLC", "SQLCCSID", "SQLIMS", "SKIP1", "SKIP2",
	"SKIP3", "SS", "SSR", "SSRANGE", "STD", "SUPPRESS", "SYSEIB", "SZ", "TERM",
	"TERMINAL", "TEST", "THREAD", "TITLE", "TRIG", "TRUNC", "UE", "UPPER",
	"VBREF", "WD", "WORD", "XMLPARSE", "XMLSS", "XOPTS", "XP", "XREF", "YEARWINDOW",
	"YW", "ZWB", "C_CHAR", "D_CHAR", "E_CHAR", "F_CHAR", "H_CHAR", "I_CHAR",
	"M_CHAR", "N_CHAR", "Q_CHAR", "S_CHAR", "U_CHAR", "W_CHAR", "X_CHAR", "COMMENTTAG",
	"COMMACHAR", "DOT", "DOUBLEEQUALCHAR", "NONNUMERICLITERAL", "NUMERICLITERAL",
	"IDENTIFIER", "FILENAME", "NEWLINE", "COMMENTLINE", "WS", "TEXT",
}

var ruleNames = []string{
	"startRule", "compilerOptions", "compilerXOpts", "compilerOption", "execCicsStatement",
	"execSqlStatement", "execSqlImsStatement", "copyStatement", "copySource",
	"copyLibrary", "replacingPhrase", "replaceArea", "replaceByStatement",
	"replaceOffStatement", "replaceClause", "directoryPhrase", "familyPhrase",
	"replaceable", "replacement", "ejectStatement", "skipStatement", "titleStatement",
	"pseudoText", "charData", "charDataSql", "charDataLine", "cobolWord", "literal",
	"filename", "charDataKeyword",
}
var decisionToDFA = make([]*antlr.DFA, len(deserializedATN.DecisionToState))

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

type Cobol85PreprocessorParser struct {
	*antlr.BaseParser
}

func NewCobol85PreprocessorParser(input antlr.TokenStream) *Cobol85PreprocessorParser {
	this := new(Cobol85PreprocessorParser)

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

	return this
}

// Cobol85PreprocessorParser tokens.
const (
	Cobol85PreprocessorParserEOF               = antlr.TokenEOF
	Cobol85PreprocessorParserADATA             = 1
	Cobol85PreprocessorParserADV               = 2
	Cobol85PreprocessorParserALIAS             = 3
	Cobol85PreprocessorParserANSI              = 4
	Cobol85PreprocessorParserANY               = 5
	Cobol85PreprocessorParserAPOST             = 6
	Cobol85PreprocessorParserAR                = 7
	Cobol85PreprocessorParserARITH             = 8
	Cobol85PreprocessorParserAUTO              = 9
	Cobol85PreprocessorParserAWO               = 10
	Cobol85PreprocessorParserBIN               = 11
	Cobol85PreprocessorParserBLOCK0            = 12
	Cobol85PreprocessorParserBUF               = 13
	Cobol85PreprocessorParserBUFSIZE           = 14
	Cobol85PreprocessorParserBY                = 15
	Cobol85PreprocessorParserCBL               = 16
	Cobol85PreprocessorParserCBLCARD           = 17
	Cobol85PreprocessorParserCICS              = 18
	Cobol85PreprocessorParserCO                = 19
	Cobol85PreprocessorParserCOBOL2            = 20
	Cobol85PreprocessorParserCOBOL3            = 21
	Cobol85PreprocessorParserCODEPAGE          = 22
	Cobol85PreprocessorParserCOMPAT            = 23
	Cobol85PreprocessorParserCOMPILE           = 24
	Cobol85PreprocessorParserCOPY              = 25
	Cobol85PreprocessorParserCP                = 26
	Cobol85PreprocessorParserCPP               = 27
	Cobol85PreprocessorParserCPSM              = 28
	Cobol85PreprocessorParserCS                = 29
	Cobol85PreprocessorParserCURR              = 30
	Cobol85PreprocessorParserCURRENCY          = 31
	Cobol85PreprocessorParserDATA              = 32
	Cobol85PreprocessorParserDATEPROC          = 33
	Cobol85PreprocessorParserDBCS              = 34
	Cobol85PreprocessorParserDD                = 35
	Cobol85PreprocessorParserDEBUG             = 36
	Cobol85PreprocessorParserDECK              = 37
	Cobol85PreprocessorParserDIAGTRUNC         = 38
	Cobol85PreprocessorParserDLI               = 39
	Cobol85PreprocessorParserDLL               = 40
	Cobol85PreprocessorParserDP                = 41
	Cobol85PreprocessorParserDTR               = 42
	Cobol85PreprocessorParserDU                = 43
	Cobol85PreprocessorParserDUMP              = 44
	Cobol85PreprocessorParserDYN               = 45
	Cobol85PreprocessorParserDYNAM             = 46
	Cobol85PreprocessorParserEDF               = 47
	Cobol85PreprocessorParserEJECT             = 48
	Cobol85PreprocessorParserEJPD              = 49
	Cobol85PreprocessorParserEN                = 50
	Cobol85PreprocessorParserENGLISH           = 51
	Cobol85PreprocessorParserEND_EXEC          = 52
	Cobol85PreprocessorParserEPILOG            = 53
	Cobol85PreprocessorParserEXCI              = 54
	Cobol85PreprocessorParserEXEC              = 55
	Cobol85PreprocessorParserEXIT              = 56
	Cobol85PreprocessorParserEXP               = 57
	Cobol85PreprocessorParserEXPORTALL         = 58
	Cobol85PreprocessorParserEXTEND            = 59
	Cobol85PreprocessorParserFASTSRT           = 60
	Cobol85PreprocessorParserFEPI              = 61
	Cobol85PreprocessorParserFLAG              = 62
	Cobol85PreprocessorParserFLAGSTD           = 63
	Cobol85PreprocessorParserFSRT              = 64
	Cobol85PreprocessorParserFULL              = 65
	Cobol85PreprocessorParserGDS               = 66
	Cobol85PreprocessorParserGRAPHIC           = 67
	Cobol85PreprocessorParserHOOK              = 68
	Cobol85PreprocessorParserIN                = 69
	Cobol85PreprocessorParserINTDATE           = 70
	Cobol85PreprocessorParserJA                = 71
	Cobol85PreprocessorParserJP                = 72
	Cobol85PreprocessorParserKA                = 73
	Cobol85PreprocessorParserLANG              = 74
	Cobol85PreprocessorParserLANGUAGE          = 75
	Cobol85PreprocessorParserLC                = 76
	Cobol85PreprocessorParserLEASM             = 77
	Cobol85PreprocessorParserLENGTH            = 78
	Cobol85PreprocessorParserLIB               = 79
	Cobol85PreprocessorParserLILIAN            = 80
	Cobol85PreprocessorParserLIN               = 81
	Cobol85PreprocessorParserLINECOUNT         = 82
	Cobol85PreprocessorParserLINKAGE           = 83
	Cobol85PreprocessorParserLIST              = 84
	Cobol85PreprocessorParserLM                = 85
	Cobol85PreprocessorParserLONGMIXED         = 86
	Cobol85PreprocessorParserLONGUPPER         = 87
	Cobol85PreprocessorParserLPARENCHAR        = 88
	Cobol85PreprocessorParserLU                = 89
	Cobol85PreprocessorParserMAP               = 90
	Cobol85PreprocessorParserMARGINS           = 91
	Cobol85PreprocessorParserMAX               = 92
	Cobol85PreprocessorParserMD                = 93
	Cobol85PreprocessorParserMDECK             = 94
	Cobol85PreprocessorParserMIG               = 95
	Cobol85PreprocessorParserMIXED             = 96
	Cobol85PreprocessorParserNAME              = 97
	Cobol85PreprocessorParserNAT               = 98
	Cobol85PreprocessorParserNATIONAL          = 99
	Cobol85PreprocessorParserNATLANG           = 100
	Cobol85PreprocessorParserNN                = 101
	Cobol85PreprocessorParserNO                = 102
	Cobol85PreprocessorParserNOADATA           = 103
	Cobol85PreprocessorParserNOADV             = 104
	Cobol85PreprocessorParserNOALIAS           = 105
	Cobol85PreprocessorParserNOAWO             = 106
	Cobol85PreprocessorParserNOBLOCK0          = 107
	Cobol85PreprocessorParserNOC               = 108
	Cobol85PreprocessorParserNOCBLCARD         = 109
	Cobol85PreprocessorParserNOCICS            = 110
	Cobol85PreprocessorParserNOCMPR2           = 111
	Cobol85PreprocessorParserNOCOMPILE         = 112
	Cobol85PreprocessorParserNOCPSM            = 113
	Cobol85PreprocessorParserNOCURR            = 114
	Cobol85PreprocessorParserNOCURRENCY        = 115
	Cobol85PreprocessorParserNOD               = 116
	Cobol85PreprocessorParserNODATEPROC        = 117
	Cobol85PreprocessorParserNODBCS            = 118
	Cobol85PreprocessorParserNODE              = 119
	Cobol85PreprocessorParserNODEBUG           = 120
	Cobol85PreprocessorParserNODECK            = 121
	Cobol85PreprocessorParserNODIAGTRUNC       = 122
	Cobol85PreprocessorParserNODLL             = 123
	Cobol85PreprocessorParserNODU              = 124
	Cobol85PreprocessorParserNODUMP            = 125
	Cobol85PreprocessorParserNODP              = 126
	Cobol85PreprocessorParserNODTR             = 127
	Cobol85PreprocessorParserNODYN             = 128
	Cobol85PreprocessorParserNODYNAM           = 129
	Cobol85PreprocessorParserNOEDF             = 130
	Cobol85PreprocessorParserNOEJPD            = 131
	Cobol85PreprocessorParserNOEPILOG          = 132
	Cobol85PreprocessorParserNOEXIT            = 133
	Cobol85PreprocessorParserNOEXP             = 134
	Cobol85PreprocessorParserNOEXPORTALL       = 135
	Cobol85PreprocessorParserNOF               = 136
	Cobol85PreprocessorParserNOFASTSRT         = 137
	Cobol85PreprocessorParserNOFEPI            = 138
	Cobol85PreprocessorParserNOFLAG            = 139
	Cobol85PreprocessorParserNOFLAGMIG         = 140
	Cobol85PreprocessorParserNOFLAGSTD         = 141
	Cobol85PreprocessorParserNOFSRT            = 142
	Cobol85PreprocessorParserNOGRAPHIC         = 143
	Cobol85PreprocessorParserNOHOOK            = 144
	Cobol85PreprocessorParserNOLENGTH          = 145
	Cobol85PreprocessorParserNOLIB             = 146
	Cobol85PreprocessorParserNOLINKAGE         = 147
	Cobol85PreprocessorParserNOLIST            = 148
	Cobol85PreprocessorParserNOMAP             = 149
	Cobol85PreprocessorParserNOMD              = 150
	Cobol85PreprocessorParserNOMDECK           = 151
	Cobol85PreprocessorParserNONAME            = 152
	Cobol85PreprocessorParserNONUM             = 153
	Cobol85PreprocessorParserNONUMBER          = 154
	Cobol85PreprocessorParserNOOBJ             = 155
	Cobol85PreprocessorParserNOOBJECT          = 156
	Cobol85PreprocessorParserNOOFF             = 157
	Cobol85PreprocessorParserNOOFFSET          = 158
	Cobol85PreprocessorParserNOOPSEQUENCE      = 159
	Cobol85PreprocessorParserNOOPT             = 160
	Cobol85PreprocessorParserNOOPTIMIZE        = 161
	Cobol85PreprocessorParserNOOPTIONS         = 162
	Cobol85PreprocessorParserNOP               = 163
	Cobol85PreprocessorParserNOPFD             = 164
	Cobol85PreprocessorParserNOPROLOG          = 165
	Cobol85PreprocessorParserNORENT            = 166
	Cobol85PreprocessorParserNOS               = 167
	Cobol85PreprocessorParserNOSEP             = 168
	Cobol85PreprocessorParserNOSEPARATE        = 169
	Cobol85PreprocessorParserNOSEQ             = 170
	Cobol85PreprocessorParserNOSOURCE          = 171
	Cobol85PreprocessorParserNOSPIE            = 172
	Cobol85PreprocessorParserNOSQL             = 173
	Cobol85PreprocessorParserNOSQLC            = 174
	Cobol85PreprocessorParserNOSQLCCSID        = 175
	Cobol85PreprocessorParserNOSSR             = 176
	Cobol85PreprocessorParserNOSSRANGE         = 177
	Cobol85PreprocessorParserNOSTDTRUNC        = 178
	Cobol85PreprocessorParserNOSEQUENCE        = 179
	Cobol85PreprocessorParserNOTERM            = 180
	Cobol85PreprocessorParserNOTERMINAL        = 181
	Cobol85PreprocessorParserNOTEST            = 182
	Cobol85PreprocessorParserNOTHREAD          = 183
	Cobol85PreprocessorParserNOTRIG            = 184
	Cobol85PreprocessorParserNOVBREF           = 185
	Cobol85PreprocessorParserNOWD              = 186
	Cobol85PreprocessorParserNOWORD            = 187
	Cobol85PreprocessorParserNOX               = 188
	Cobol85PreprocessorParserNOXREF            = 189
	Cobol85PreprocessorParserNOZWB             = 190
	Cobol85PreprocessorParserNS                = 191
	Cobol85PreprocessorParserNSEQ              = 192
	Cobol85PreprocessorParserNSYMBOL           = 193
	Cobol85PreprocessorParserNUM               = 194
	Cobol85PreprocessorParserNUMBER            = 195
	Cobol85PreprocessorParserNUMPROC           = 196
	Cobol85PreprocessorParserOBJ               = 197
	Cobol85PreprocessorParserOBJECT            = 198
	Cobol85PreprocessorParserOF                = 199
	Cobol85PreprocessorParserOFF               = 200
	Cobol85PreprocessorParserOFFSET            = 201
	Cobol85PreprocessorParserON                = 202
	Cobol85PreprocessorParserOP                = 203
	Cobol85PreprocessorParserOPMARGINS         = 204
	Cobol85PreprocessorParserOPSEQUENCE        = 205
	Cobol85PreprocessorParserOPT               = 206
	Cobol85PreprocessorParserOPTFILE           = 207
	Cobol85PreprocessorParserOPTIMIZE          = 208
	Cobol85PreprocessorParserOPTIONS           = 209
	Cobol85PreprocessorParserOUT               = 210
	Cobol85PreprocessorParserOUTDD             = 211
	Cobol85PreprocessorParserPFD               = 212
	Cobol85PreprocessorParserPPTDBG            = 213
	Cobol85PreprocessorParserPGMN              = 214
	Cobol85PreprocessorParserPGMNAME           = 215
	Cobol85PreprocessorParserPROCESS           = 216
	Cobol85PreprocessorParserPROLOG            = 217
	Cobol85PreprocessorParserQUOTE             = 218
	Cobol85PreprocessorParserRENT              = 219
	Cobol85PreprocessorParserREPLACE           = 220
	Cobol85PreprocessorParserREPLACING         = 221
	Cobol85PreprocessorParserRMODE             = 222
	Cobol85PreprocessorParserRPARENCHAR        = 223
	Cobol85PreprocessorParserSEP               = 224
	Cobol85PreprocessorParserSEPARATE          = 225
	Cobol85PreprocessorParserSEQ               = 226
	Cobol85PreprocessorParserSEQUENCE          = 227
	Cobol85PreprocessorParserSHORT             = 228
	Cobol85PreprocessorParserSIZE              = 229
	Cobol85PreprocessorParserSOURCE            = 230
	Cobol85PreprocessorParserSP                = 231
	Cobol85PreprocessorParserSPACE             = 232
	Cobol85PreprocessorParserSPIE              = 233
	Cobol85PreprocessorParserSQL               = 234
	Cobol85PreprocessorParserSQLC              = 235
	Cobol85PreprocessorParserSQLCCSID          = 236
	Cobol85PreprocessorParserSQLIMS            = 237
	Cobol85PreprocessorParserSKIP1             = 238
	Cobol85PreprocessorParserSKIP2             = 239
	Cobol85PreprocessorParserSKIP3             = 240
	Cobol85PreprocessorParserSS                = 241
	Cobol85PreprocessorParserSSR               = 242
	Cobol85PreprocessorParserSSRANGE           = 243
	Cobol85PreprocessorParserSTD               = 244
	Cobol85PreprocessorParserSUPPRESS          = 245
	Cobol85PreprocessorParserSYSEIB            = 246
	Cobol85PreprocessorParserSZ                = 247
	Cobol85PreprocessorParserTERM              = 248
	Cobol85PreprocessorParserTERMINAL          = 249
	Cobol85PreprocessorParserTEST              = 250
	Cobol85PreprocessorParserTHREAD            = 251
	Cobol85PreprocessorParserTITLE             = 252
	Cobol85PreprocessorParserTRIG              = 253
	Cobol85PreprocessorParserTRUNC             = 254
	Cobol85PreprocessorParserUE                = 255
	Cobol85PreprocessorParserUPPER             = 256
	Cobol85PreprocessorParserVBREF             = 257
	Cobol85PreprocessorParserWD                = 258
	Cobol85PreprocessorParserWORD              = 259
	Cobol85PreprocessorParserXMLPARSE          = 260
	Cobol85PreprocessorParserXMLSS             = 261
	Cobol85PreprocessorParserXOPTS             = 262
	Cobol85PreprocessorParserXP                = 263
	Cobol85PreprocessorParserXREF              = 264
	Cobol85PreprocessorParserYEARWINDOW        = 265
	Cobol85PreprocessorParserYW                = 266
	Cobol85PreprocessorParserZWB               = 267
	Cobol85PreprocessorParserC_CHAR            = 268
	Cobol85PreprocessorParserD_CHAR            = 269
	Cobol85PreprocessorParserE_CHAR            = 270
	Cobol85PreprocessorParserF_CHAR            = 271
	Cobol85PreprocessorParserH_CHAR            = 272
	Cobol85PreprocessorParserI_CHAR            = 273
	Cobol85PreprocessorParserM_CHAR            = 274
	Cobol85PreprocessorParserN_CHAR            = 275
	Cobol85PreprocessorParserQ_CHAR            = 276
	Cobol85PreprocessorParserS_CHAR            = 277
	Cobol85PreprocessorParserU_CHAR            = 278
	Cobol85PreprocessorParserW_CHAR            = 279
	Cobol85PreprocessorParserX_CHAR            = 280
	Cobol85PreprocessorParserCOMMENTTAG        = 281
	Cobol85PreprocessorParserCOMMACHAR         = 282
	Cobol85PreprocessorParserDOT               = 283
	Cobol85PreprocessorParserDOUBLEEQUALCHAR   = 284
	Cobol85PreprocessorParserNONNUMERICLITERAL = 285
	Cobol85PreprocessorParserNUMERICLITERAL    = 286
	Cobol85PreprocessorParserIDENTIFIER        = 287
	Cobol85PreprocessorParserFILENAME          = 288
	Cobol85PreprocessorParserNEWLINE           = 289
	Cobol85PreprocessorParserCOMMENTLINE       = 290
	Cobol85PreprocessorParserWS                = 291
	Cobol85PreprocessorParserTEXT              = 292
)

// Cobol85PreprocessorParser rules.
const (
	Cobol85PreprocessorParserRULE_startRule           = 0
	Cobol85PreprocessorParserRULE_compilerOptions     = 1
	Cobol85PreprocessorParserRULE_compilerXOpts       = 2
	Cobol85PreprocessorParserRULE_compilerOption      = 3
	Cobol85PreprocessorParserRULE_execCicsStatement   = 4
	Cobol85PreprocessorParserRULE_execSqlStatement    = 5
	Cobol85PreprocessorParserRULE_execSqlImsStatement = 6
	Cobol85PreprocessorParserRULE_copyStatement       = 7
	Cobol85PreprocessorParserRULE_copySource          = 8
	Cobol85PreprocessorParserRULE_copyLibrary         = 9
	Cobol85PreprocessorParserRULE_replacingPhrase     = 10
	Cobol85PreprocessorParserRULE_replaceArea         = 11
	Cobol85PreprocessorParserRULE_replaceByStatement  = 12
	Cobol85PreprocessorParserRULE_replaceOffStatement = 13
	Cobol85PreprocessorParserRULE_replaceClause       = 14
	Cobol85PreprocessorParserRULE_directoryPhrase     = 15
	Cobol85PreprocessorParserRULE_familyPhrase        = 16
	Cobol85PreprocessorParserRULE_replaceable         = 17
	Cobol85PreprocessorParserRULE_replacement         = 18
	Cobol85PreprocessorParserRULE_ejectStatement      = 19
	Cobol85PreprocessorParserRULE_skipStatement       = 20
	Cobol85PreprocessorParserRULE_titleStatement      = 21
	Cobol85PreprocessorParserRULE_pseudoText          = 22
	Cobol85PreprocessorParserRULE_charData            = 23
	Cobol85PreprocessorParserRULE_charDataSql         = 24
	Cobol85PreprocessorParserRULE_charDataLine        = 25
	Cobol85PreprocessorParserRULE_cobolWord           = 26
	Cobol85PreprocessorParserRULE_literal             = 27
	Cobol85PreprocessorParserRULE_filename            = 28
	Cobol85PreprocessorParserRULE_charDataKeyword     = 29
)

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

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

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

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

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

func (*StartRuleContext) IsStartRuleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_startRule

	return p
}

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

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

func (s *StartRuleContext) AllCompilerOptions() []ICompilerOptionsContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompilerOptionsContext)(nil)).Elem())
	var tst = make([]ICompilerOptionsContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) CompilerOptions(i int) ICompilerOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompilerOptionsContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompilerOptionsContext)
}

func (s *StartRuleContext) AllCopyStatement() []ICopyStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICopyStatementContext)(nil)).Elem())
	var tst = make([]ICopyStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) CopyStatement(i int) ICopyStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICopyStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICopyStatementContext)
}

func (s *StartRuleContext) AllExecCicsStatement() []IExecCicsStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExecCicsStatementContext)(nil)).Elem())
	var tst = make([]IExecCicsStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) ExecCicsStatement(i int) IExecCicsStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExecCicsStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExecCicsStatementContext)
}

func (s *StartRuleContext) AllExecSqlStatement() []IExecSqlStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExecSqlStatementContext)(nil)).Elem())
	var tst = make([]IExecSqlStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) ExecSqlStatement(i int) IExecSqlStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExecSqlStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExecSqlStatementContext)
}

func (s *StartRuleContext) AllExecSqlImsStatement() []IExecSqlImsStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExecSqlImsStatementContext)(nil)).Elem())
	var tst = make([]IExecSqlImsStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) ExecSqlImsStatement(i int) IExecSqlImsStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExecSqlImsStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExecSqlImsStatementContext)
}

func (s *StartRuleContext) AllReplaceOffStatement() []IReplaceOffStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplaceOffStatementContext)(nil)).Elem())
	var tst = make([]IReplaceOffStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) ReplaceOffStatement(i int) IReplaceOffStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceOffStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplaceOffStatementContext)
}

func (s *StartRuleContext) AllReplaceArea() []IReplaceAreaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplaceAreaContext)(nil)).Elem())
	var tst = make([]IReplaceAreaContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) ReplaceArea(i int) IReplaceAreaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceAreaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplaceAreaContext)
}

func (s *StartRuleContext) AllEjectStatement() []IEjectStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEjectStatementContext)(nil)).Elem())
	var tst = make([]IEjectStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) EjectStatement(i int) IEjectStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEjectStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEjectStatementContext)
}

func (s *StartRuleContext) AllSkipStatement() []ISkipStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISkipStatementContext)(nil)).Elem())
	var tst = make([]ISkipStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) SkipStatement(i int) ISkipStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISkipStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISkipStatementContext)
}

func (s *StartRuleContext) AllTitleStatement() []ITitleStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITitleStatementContext)(nil)).Elem())
	var tst = make([]ITitleStatementContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) TitleStatement(i int) ITitleStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITitleStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITitleStatementContext)
}

func (s *StartRuleContext) AllCharDataLine() []ICharDataLineContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem())
	var tst = make([]ICharDataLineContext, len(ts))

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

	return tst
}

func (s *StartRuleContext) CharDataLine(i int) ICharDataLineContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICharDataLineContext)
}

func (s *StartRuleContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

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

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

func (p *Cobol85PreprocessorParser) StartRule() (localctx IStartRuleContext) {
	localctx = NewStartRuleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, Cobol85PreprocessorParserRULE_startRule)
	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(74)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Cobol85PreprocessorParserADATA)|(1<<Cobol85PreprocessorParserADV)|(1<<Cobol85PreprocessorParserALIAS)|(1<<Cobol85PreprocessorParserANSI)|(1<<Cobol85PreprocessorParserANY)|(1<<Cobol85PreprocessorParserAPOST)|(1<<Cobol85PreprocessorParserAR)|(1<<Cobol85PreprocessorParserARITH)|(1<<Cobol85PreprocessorParserAUTO)|(1<<Cobol85PreprocessorParserAWO)|(1<<Cobol85PreprocessorParserBIN)|(1<<Cobol85PreprocessorParserBLOCK0)|(1<<Cobol85PreprocessorParserBUF)|(1<<Cobol85PreprocessorParserBUFSIZE)|(1<<Cobol85PreprocessorParserBY)|(1<<Cobol85PreprocessorParserCBL)|(1<<Cobol85PreprocessorParserCBLCARD)|(1<<Cobol85PreprocessorParserCO)|(1<<Cobol85PreprocessorParserCOBOL2)|(1<<Cobol85PreprocessorParserCOBOL3)|(1<<Cobol85PreprocessorParserCODEPAGE)|(1<<Cobol85PreprocessorParserCOMPAT)|(1<<Cobol85PreprocessorParserCOMPILE)|(1<<Cobol85PreprocessorParserCOPY)|(1<<Cobol85PreprocessorParserCP)|(1<<Cobol85PreprocessorParserCPP)|(1<<Cobol85PreprocessorParserCPSM)|(1<<Cobol85PreprocessorParserCS)|(1<<Cobol85PreprocessorParserCURR)|(1<<Cobol85PreprocessorParserCURRENCY))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(Cobol85PreprocessorParserDATA-32))|(1<<(Cobol85PreprocessorParserDATEPROC-32))|(1<<(Cobol85PreprocessorParserDBCS-32))|(1<<(Cobol85PreprocessorParserDD-32))|(1<<(Cobol85PreprocessorParserDEBUG-32))|(1<<(Cobol85PreprocessorParserDECK-32))|(1<<(Cobol85PreprocessorParserDIAGTRUNC-32))|(1<<(Cobol85PreprocessorParserDLI-32))|(1<<(Cobol85PreprocessorParserDLL-32))|(1<<(Cobol85PreprocessorParserDP-32))|(1<<(Cobol85PreprocessorParserDTR-32))|(1<<(Cobol85PreprocessorParserDU-32))|(1<<(Cobol85PreprocessorParserDUMP-32))|(1<<(Cobol85PreprocessorParserDYN-32))|(1<<(Cobol85PreprocessorParserDYNAM-32))|(1<<(Cobol85PreprocessorParserEDF-32))|(1<<(Cobol85PreprocessorParserEJECT-32))|(1<<(Cobol85PreprocessorParserEJPD-32))|(1<<(Cobol85PreprocessorParserEN-32))|(1<<(Cobol85PreprocessorParserENGLISH-32))|(1<<(Cobol85PreprocessorParserEPILOG-32))|(1<<(Cobol85PreprocessorParserEXCI-32))|(1<<(Cobol85PreprocessorParserEXEC-32))|(1<<(Cobol85PreprocessorParserEXIT-32))|(1<<(Cobol85PreprocessorParserEXP-32))|(1<<(Cobol85PreprocessorParserEXPORTALL-32))|(1<<(Cobol85PreprocessorParserEXTEND-32))|(1<<(Cobol85PreprocessorParserFASTSRT-32))|(1<<(Cobol85PreprocessorParserFLAG-32))|(1<<(Cobol85PreprocessorParserFLAGSTD-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(Cobol85PreprocessorParserFSRT-64))|(1<<(Cobol85PreprocessorParserFULL-64))|(1<<(Cobol85PreprocessorParserGDS-64))|(1<<(Cobol85PreprocessorParserGRAPHIC-64))|(1<<(Cobol85PreprocessorParserHOOK-64))|(1<<(Cobol85PreprocessorParserIN-64))|(1<<(Cobol85PreprocessorParserINTDATE-64))|(1<<(Cobol85PreprocessorParserJA-64))|(1<<(Cobol85PreprocessorParserJP-64))|(1<<(Cobol85PreprocessorParserKA-64))|(1<<(Cobol85PreprocessorParserLANG-64))|(1<<(Cobol85PreprocessorParserLANGUAGE-64))|(1<<(Cobol85PreprocessorParserLC-64))|(1<<(Cobol85PreprocessorParserLENGTH-64))|(1<<(Cobol85PreprocessorParserLIB-64))|(1<<(Cobol85PreprocessorParserLILIAN-64))|(1<<(Cobol85PreprocessorParserLIN-64))|(1<<(Cobol85PreprocessorParserLINECOUNT-64))|(1<<(Cobol85PreprocessorParserLINKAGE-64))|(1<<(Cobol85PreprocessorParserLIST-64))|(1<<(Cobol85PreprocessorParserLM-64))|(1<<(Cobol85PreprocessorParserLONGMIXED-64))|(1<<(Cobol85PreprocessorParserLONGUPPER-64))|(1<<(Cobol85PreprocessorParserLPARENCHAR-64))|(1<<(Cobol85PreprocessorParserLU-64))|(1<<(Cobol85PreprocessorParserMAP-64))|(1<<(Cobol85PreprocessorParserMARGINS-64))|(1<<(Cobol85PreprocessorParserMAX-64))|(1<<(Cobol85PreprocessorParserMD-64))|(1<<(Cobol85PreprocessorParserMDECK-64))|(1<<(Cobol85PreprocessorParserMIG-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(Cobol85PreprocessorParserMIXED-96))|(1<<(Cobol85PreprocessorParserNAME-96))|(1<<(Cobol85PreprocessorParserNAT-96))|(1<<(Cobol85PreprocessorParserNATIONAL-96))|(1<<(Cobol85PreprocessorParserNATLANG-96))|(1<<(Cobol85PreprocessorParserNN-96))|(1<<(Cobol85PreprocessorParserNO-96))|(1<<(Cobol85PreprocessorParserNOADATA-96))|(1<<(Cobol85PreprocessorParserNOADV-96))|(1<<(Cobol85PreprocessorParserNOALIAS-96))|(1<<(Cobol85PreprocessorParserNOAWO-96))|(1<<(Cobol85PreprocessorParserNOBLOCK0-96))|(1<<(Cobol85PreprocessorParserNOC-96))|(1<<(Cobol85PreprocessorParserNOCBLCARD-96))|(1<<(Cobol85PreprocessorParserNOCICS-96))|(1<<(Cobol85PreprocessorParserNOCMPR2-96))|(1<<(Cobol85PreprocessorParserNOCOMPILE-96))|(1<<(Cobol85PreprocessorParserNOCPSM-96))|(1<<(Cobol85PreprocessorParserNOCURR-96))|(1<<(Cobol85PreprocessorParserNOCURRENCY-96))|(1<<(Cobol85PreprocessorParserNOD-96))|(1<<(Cobol85PreprocessorParserNODATEPROC-96))|(1<<(Cobol85PreprocessorParserNODBCS-96))|(1<<(Cobol85PreprocessorParserNODE-96))|(1<<(Cobol85PreprocessorParserNODEBUG-96))|(1<<(Cobol85PreprocessorParserNODECK-96))|(1<<(Cobol85PreprocessorParserNODIAGTRUNC-96))|(1<<(Cobol85PreprocessorParserNODLL-96))|(1<<(Cobol85PreprocessorParserNODU-96))|(1<<(Cobol85PreprocessorParserNODUMP-96))|(1<<(Cobol85PreprocessorParserNODP-96))|(1<<(Cobol85PreprocessorParserNODTR-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(Cobol85PreprocessorParserNODYN-128))|(1<<(Cobol85PreprocessorParserNODYNAM-128))|(1<<(Cobol85PreprocessorParserNOEDF-128))|(1<<(Cobol85PreprocessorParserNOEJPD-128))|(1<<(Cobol85PreprocessorParserNOEPILOG-128))|(1<<(Cobol85PreprocessorParserNOEXIT-128))|(1<<(Cobol85PreprocessorParserNOEXP-128))|(1<<(Cobol85PreprocessorParserNOEXPORTALL-128))|(1<<(Cobol85PreprocessorParserNOF-128))|(1<<(Cobol85PreprocessorParserNOFASTSRT-128))|(1<<(Cobol85PreprocessorParserNOFEPI-128))|(1<<(Cobol85PreprocessorParserNOFLAG-128))|(1<<(Cobol85PreprocessorParserNOFLAGMIG-128))|(1<<(Cobol85PreprocessorParserNOFLAGSTD-128))|(1<<(Cobol85PreprocessorParserNOFSRT-128))|(1<<(Cobol85PreprocessorParserNOGRAPHIC-128))|(1<<(Cobol85PreprocessorParserNOHOOK-128))|(1<<(Cobol85PreprocessorParserNOLENGTH-128))|(1<<(Cobol85PreprocessorParserNOLIB-128))|(1<<(Cobol85PreprocessorParserNOLINKAGE-128))|(1<<(Cobol85PreprocessorParserNOLIST-128))|(1<<(Cobol85PreprocessorParserNOMAP-128))|(1<<(Cobol85PreprocessorParserNOMD-128))|(1<<(Cobol85PreprocessorParserNOMDECK-128))|(1<<(Cobol85PreprocessorParserNONAME-128))|(1<<(Cobol85PreprocessorParserNONUM-128))|(1<<(Cobol85PreprocessorParserNONUMBER-128))|(1<<(Cobol85PreprocessorParserNOOBJ-128))|(1<<(Cobol85PreprocessorParserNOOBJECT-128))|(1<<(Cobol85PreprocessorParserNOOFF-128))|(1<<(Cobol85PreprocessorParserNOOFFSET-128))|(1<<(Cobol85PreprocessorParserNOOPSEQUENCE-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(Cobol85PreprocessorParserNOOPT-160))|(1<<(Cobol85PreprocessorParserNOOPTIMIZE-160))|(1<<(Cobol85PreprocessorParserNOOPTIONS-160))|(1<<(Cobol85PreprocessorParserNOP-160))|(1<<(Cobol85PreprocessorParserNOPFD-160))|(1<<(Cobol85PreprocessorParserNOPROLOG-160))|(1<<(Cobol85PreprocessorParserNORENT-160))|(1<<(Cobol85PreprocessorParserNOS-160))|(1<<(Cobol85PreprocessorParserNOSEP-160))|(1<<(Cobol85PreprocessorParserNOSEPARATE-160))|(1<<(Cobol85PreprocessorParserNOSEQ-160))|(1<<(Cobol85PreprocessorParserNOSOURCE-160))|(1<<(Cobol85PreprocessorParserNOSPIE-160))|(1<<(Cobol85PreprocessorParserNOSQL-160))|(1<<(Cobol85PreprocessorParserNOSQLC-160))|(1<<(Cobol85PreprocessorParserNOSQLCCSID-160))|(1<<(Cobol85PreprocessorParserNOSSR-160))|(1<<(Cobol85PreprocessorParserNOSSRANGE-160))|(1<<(Cobol85PreprocessorParserNOSTDTRUNC-160))|(1<<(Cobol85PreprocessorParserNOSEQUENCE-160))|(1<<(Cobol85PreprocessorParserNOTERM-160))|(1<<(Cobol85PreprocessorParserNOTERMINAL-160))|(1<<(Cobol85PreprocessorParserNOTEST-160))|(1<<(Cobol85PreprocessorParserNOTHREAD-160))|(1<<(Cobol85PreprocessorParserNOTRIG-160))|(1<<(Cobol85PreprocessorParserNOVBREF-160))|(1<<(Cobol85PreprocessorParserNOWORD-160))|(1<<(Cobol85PreprocessorParserNOX-160))|(1<<(Cobol85PreprocessorParserNOXREF-160))|(1<<(Cobol85PreprocessorParserNOZWB-160))|(1<<(Cobol85PreprocessorParserNS-160)))) != 0) || (((_la-192)&-(0x1f+1)) == 0 && ((1<<uint((_la-192)))&((1<<(Cobol85PreprocessorParserNSEQ-192))|(1<<(Cobol85PreprocessorParserNSYMBOL-192))|(1<<(Cobol85PreprocessorParserNUM-192))|(1<<(Cobol85PreprocessorParserNUMBER-192))|(1<<(Cobol85PreprocessorParserNUMPROC-192))|(1<<(Cobol85PreprocessorParserOBJ-192))|(1<<(Cobol85PreprocessorParserOBJECT-192))|(1<<(Cobol85PreprocessorParserOF-192))|(1<<(Cobol85PreprocessorParserOFF-192))|(1<<(Cobol85PreprocessorParserOFFSET-192))|(1<<(Cobol85PreprocessorParserON-192))|(1<<(Cobol85PreprocessorParserOP-192))|(1<<(Cobol85PreprocessorParserOPMARGINS-192))|(1<<(Cobol85PreprocessorParserOPSEQUENCE-192))|(1<<(Cobol85PreprocessorParserOPT-192))|(1<<(Cobol85PreprocessorParserOPTFILE-192))|(1<<(Cobol85PreprocessorParserOPTIMIZE-192))|(1<<(Cobol85PreprocessorParserOPTIONS-192))|(1<<(Cobol85PreprocessorParserOUT-192))|(1<<(Cobol85PreprocessorParserOUTDD-192))|(1<<(Cobol85PreprocessorParserPFD-192))|(1<<(Cobol85PreprocessorParserPPTDBG-192))|(1<<(Cobol85PreprocessorParserPGMN-192))|(1<<(Cobol85PreprocessorParserPGMNAME-192))|(1<<(Cobol85PreprocessorParserPROCESS-192))|(1<<(Cobol85PreprocessorParserPROLOG-192))|(1<<(Cobol85PreprocessorParserQUOTE-192))|(1<<(Cobol85PreprocessorParserRENT-192))|(1<<(Cobol85PreprocessorParserREPLACE-192))|(1<<(Cobol85PreprocessorParserREPLACING-192))|(1<<(Cobol85PreprocessorParserRMODE-192))|(1<<(Cobol85PreprocessorParserRPARENCHAR-192)))) != 0) || (((_la-224)&-(0x1f+1)) == 0 && ((1<<uint((_la-224)))&((1<<(Cobol85PreprocessorParserSEP-224))|(1<<(Cobol85PreprocessorParserSEPARATE-224))|(1<<(Cobol85PreprocessorParserSEQ-224))|(1<<(Cobol85PreprocessorParserSEQUENCE-224))|(1<<(Cobol85PreprocessorParserSHORT-224))|(1<<(Cobol85PreprocessorParserSIZE-224))|(1<<(Cobol85PreprocessorParserSOURCE-224))|(1<<(Cobol85PreprocessorParserSP-224))|(1<<(Cobol85PreprocessorParserSPACE-224))|(1<<(Cobol85PreprocessorParserSPIE-224))|(1<<(Cobol85PreprocessorParserSQL-224))|(1<<(Cobol85PreprocessorParserSQLC-224))|(1<<(Cobol85PreprocessorParserSQLCCSID-224))|(1<<(Cobol85PreprocessorParserSKIP1-224))|(1<<(Cobol85PreprocessorParserSKIP2-224))|(1<<(Cobol85PreprocessorParserSKIP3-224))|(1<<(Cobol85PreprocessorParserSS-224))|(1<<(Cobol85PreprocessorParserSSR-224))|(1<<(Cobol85PreprocessorParserSSRANGE-224))|(1<<(Cobol85PreprocessorParserSTD-224))|(1<<(Cobol85PreprocessorParserSYSEIB-224))|(1<<(Cobol85PreprocessorParserSZ-224))|(1<<(Cobol85PreprocessorParserTERM-224))|(1<<(Cobol85PreprocessorParserTERMINAL-224))|(1<<(Cobol85PreprocessorParserTEST-224))|(1<<(Cobol85PreprocessorParserTHREAD-224))|(1<<(Cobol85PreprocessorParserTITLE-224))|(1<<(Cobol85PreprocessorParserTRIG-224))|(1<<(Cobol85PreprocessorParserTRUNC-224))|(1<<(Cobol85PreprocessorParserUE-224)))) != 0) || (((_la-256)&-(0x1f+1)) == 0 && ((1<<uint((_la-256)))&((1<<(Cobol85PreprocessorParserUPPER-256))|(1<<(Cobol85PreprocessorParserVBREF-256))|(1<<(Cobol85PreprocessorParserWD-256))|(1<<(Cobol85PreprocessorParserXMLPARSE-256))|(1<<(Cobol85PreprocessorParserXMLSS-256))|(1<<(Cobol85PreprocessorParserXOPTS-256))|(1<<(Cobol85PreprocessorParserXREF-256))|(1<<(Cobol85PreprocessorParserYEARWINDOW-256))|(1<<(Cobol85PreprocessorParserYW-256))|(1<<(Cobol85PreprocessorParserZWB-256))|(1<<(Cobol85PreprocessorParserC_CHAR-256))|(1<<(Cobol85PreprocessorParserD_CHAR-256))|(1<<(Cobol85PreprocessorParserE_CHAR-256))|(1<<(Cobol85PreprocessorParserF_CHAR-256))|(1<<(Cobol85PreprocessorParserH_CHAR-256))|(1<<(Cobol85PreprocessorParserI_CHAR-256))|(1<<(Cobol85PreprocessorParserM_CHAR-256))|(1<<(Cobol85PreprocessorParserN_CHAR-256))|(1<<(Cobol85PreprocessorParserQ_CHAR-256))|(1<<(Cobol85PreprocessorParserS_CHAR-256))|(1<<(Cobol85PreprocessorParserU_CHAR-256))|(1<<(Cobol85PreprocessorParserW_CHAR-256))|(1<<(Cobol85PreprocessorParserX_CHAR-256))|(1<<(Cobol85PreprocessorParserCOMMACHAR-256))|(1<<(Cobol85PreprocessorParserDOT-256))|(1<<(Cobol85PreprocessorParserNONNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserIDENTIFIER-256)))) != 0) || (((_la-288)&-(0x1f+1)) == 0 && ((1<<uint((_la-288)))&((1<<(Cobol85PreprocessorParserFILENAME-288))|(1<<(Cobol85PreprocessorParserNEWLINE-288))|(1<<(Cobol85PreprocessorParserTEXT-288)))) != 0) {
		p.SetState(72)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(60)
				p.CompilerOptions()
			}

		case 2:
			{
				p.SetState(61)
				p.CopyStatement()
			}

		case 3:
			{
				p.SetState(62)
				p.ExecCicsStatement()
			}

		case 4:
			{
				p.SetState(63)
				p.ExecSqlStatement()
			}

		case 5:
			{
				p.SetState(64)
				p.ExecSqlImsStatement()
			}

		case 6:
			{
				p.SetState(65)
				p.ReplaceOffStatement()
			}

		case 7:
			{
				p.SetState(66)
				p.ReplaceArea()
			}

		case 8:
			{
				p.SetState(67)
				p.EjectStatement()
			}

		case 9:
			{
				p.SetState(68)
				p.SkipStatement()
			}

		case 10:
			{
				p.SetState(69)
				p.TitleStatement()
			}

		case 11:
			{
				p.SetState(70)
				p.CharDataLine()
			}

		case 12:
			{
				p.SetState(71)
				p.Match(Cobol85PreprocessorParserNEWLINE)
			}

		}

		p.SetState(76)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(77)
		p.Match(Cobol85PreprocessorParserEOF)
	}

	return localctx
}

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

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

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

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

func NewEmptyCompilerOptionsContext() *CompilerOptionsContext {
	var p = new(CompilerOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerOptions
	return p
}

func (*CompilerOptionsContext) IsCompilerOptionsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerOptions

	return p
}

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

func (s *CompilerOptionsContext) PROCESS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPROCESS, 0)
}

func (s *CompilerOptionsContext) CBL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCBL, 0)
}

func (s *CompilerOptionsContext) AllCompilerOption() []ICompilerOptionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompilerOptionContext)(nil)).Elem())
	var tst = make([]ICompilerOptionContext, len(ts))

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

	return tst
}

func (s *CompilerOptionsContext) CompilerOption(i int) ICompilerOptionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompilerOptionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompilerOptionContext)
}

func (s *CompilerOptionsContext) AllCompilerXOpts() []ICompilerXOptsContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompilerXOptsContext)(nil)).Elem())
	var tst = make([]ICompilerXOptsContext, len(ts))

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

	return tst
}

func (s *CompilerOptionsContext) CompilerXOpts(i int) ICompilerXOptsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompilerXOptsContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompilerXOptsContext)
}

func (s *CompilerOptionsContext) AllCOMMACHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserCOMMACHAR)
}

func (s *CompilerOptionsContext) COMMACHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMMACHAR, i)
}

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

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

func (s *CompilerOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCompilerOptions(s)
	}
}

func (s *CompilerOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCompilerOptions(s)
	}
}

func (p *Cobol85PreprocessorParser) CompilerOptions() (localctx ICompilerOptionsContext) {
	localctx = NewCompilerOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, Cobol85PreprocessorParserRULE_compilerOptions)
	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(79)
		_la = p.GetTokenStream().LA(1)

		if !(_la == Cobol85PreprocessorParserCBL || _la == Cobol85PreprocessorParserPROCESS) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(85)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			p.SetState(85)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCICS, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFEPI, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLEASM, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWD, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserWORD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXP, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR:
				p.SetState(81)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == Cobol85PreprocessorParserCOMMACHAR {
					{
						p.SetState(80)
						p.Match(Cobol85PreprocessorParserCOMMACHAR)
					}

				}
				{
					p.SetState(83)
					p.CompilerOption()
				}

			case Cobol85PreprocessorParserXOPTS:
				{
					p.SetState(84)
					p.CompilerXOpts()
				}

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

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

		p.SetState(87)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyCompilerXOptsContext() *CompilerXOptsContext {
	var p = new(CompilerXOptsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerXOpts
	return p
}

func (*CompilerXOptsContext) IsCompilerXOptsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerXOpts

	return p
}

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

func (s *CompilerXOptsContext) XOPTS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXOPTS, 0)
}

func (s *CompilerXOptsContext) LPARENCHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLPARENCHAR, 0)
}

func (s *CompilerXOptsContext) AllCompilerOption() []ICompilerOptionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompilerOptionContext)(nil)).Elem())
	var tst = make([]ICompilerOptionContext, len(ts))

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

	return tst
}

func (s *CompilerXOptsContext) CompilerOption(i int) ICompilerOptionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompilerOptionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompilerOptionContext)
}

func (s *CompilerXOptsContext) RPARENCHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRPARENCHAR, 0)
}

func (s *CompilerXOptsContext) AllCOMMACHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserCOMMACHAR)
}

func (s *CompilerXOptsContext) COMMACHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMMACHAR, i)
}

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

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

func (s *CompilerXOptsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCompilerXOpts(s)
	}
}

func (s *CompilerXOptsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCompilerXOpts(s)
	}
}

func (p *Cobol85PreprocessorParser) CompilerXOpts() (localctx ICompilerXOptsContext) {
	localctx = NewCompilerXOptsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, Cobol85PreprocessorParserRULE_compilerXOpts)
	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(89)
		p.Match(Cobol85PreprocessorParserXOPTS)
	}
	{
		p.SetState(90)
		p.Match(Cobol85PreprocessorParserLPARENCHAR)
	}
	{
		p.SetState(91)
		p.CompilerOption()
	}
	p.SetState(98)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Cobol85PreprocessorParserADATA)|(1<<Cobol85PreprocessorParserADV)|(1<<Cobol85PreprocessorParserAPOST)|(1<<Cobol85PreprocessorParserAR)|(1<<Cobol85PreprocessorParserARITH)|(1<<Cobol85PreprocessorParserAWO)|(1<<Cobol85PreprocessorParserBLOCK0)|(1<<Cobol85PreprocessorParserBUF)|(1<<Cobol85PreprocessorParserBUFSIZE)|(1<<Cobol85PreprocessorParserCBLCARD)|(1<<Cobol85PreprocessorParserCICS)|(1<<Cobol85PreprocessorParserCOBOL2)|(1<<Cobol85PreprocessorParserCOBOL3)|(1<<Cobol85PreprocessorParserCODEPAGE)|(1<<Cobol85PreprocessorParserCOMPILE)|(1<<Cobol85PreprocessorParserCP)|(1<<Cobol85PreprocessorParserCPP)|(1<<Cobol85PreprocessorParserCPSM)|(1<<Cobol85PreprocessorParserCURR)|(1<<Cobol85PreprocessorParserCURRENCY))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(Cobol85PreprocessorParserDATA-32))|(1<<(Cobol85PreprocessorParserDATEPROC-32))|(1<<(Cobol85PreprocessorParserDBCS-32))|(1<<(Cobol85PreprocessorParserDEBUG-32))|(1<<(Cobol85PreprocessorParserDECK-32))|(1<<(Cobol85PreprocessorParserDIAGTRUNC-32))|(1<<(Cobol85PreprocessorParserDLL-32))|(1<<(Cobol85PreprocessorParserDP-32))|(1<<(Cobol85PreprocessorParserDTR-32))|(1<<(Cobol85PreprocessorParserDU-32))|(1<<(Cobol85PreprocessorParserDUMP-32))|(1<<(Cobol85PreprocessorParserDYN-32))|(1<<(Cobol85PreprocessorParserDYNAM-32))|(1<<(Cobol85PreprocessorParserEDF-32))|(1<<(Cobol85PreprocessorParserEPILOG-32))|(1<<(Cobol85PreprocessorParserEXIT-32))|(1<<(Cobol85PreprocessorParserEXP-32))|(1<<(Cobol85PreprocessorParserEXPORTALL-32))|(1<<(Cobol85PreprocessorParserFASTSRT-32))|(1<<(Cobol85PreprocessorParserFEPI-32))|(1<<(Cobol85PreprocessorParserFLAG-32))|(1<<(Cobol85PreprocessorParserFLAGSTD-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(Cobol85PreprocessorParserFSRT-64))|(1<<(Cobol85PreprocessorParserGDS-64))|(1<<(Cobol85PreprocessorParserGRAPHIC-64))|(1<<(Cobol85PreprocessorParserINTDATE-64))|(1<<(Cobol85PreprocessorParserLANG-64))|(1<<(Cobol85PreprocessorParserLANGUAGE-64))|(1<<(Cobol85PreprocessorParserLC-64))|(1<<(Cobol85PreprocessorParserLEASM-64))|(1<<(Cobol85PreprocessorParserLENGTH-64))|(1<<(Cobol85PreprocessorParserLIB-64))|(1<<(Cobol85PreprocessorParserLIN-64))|(1<<(Cobol85PreprocessorParserLINECOUNT-64))|(1<<(Cobol85PreprocessorParserLINKAGE-64))|(1<<(Cobol85PreprocessorParserLIST-64))|(1<<(Cobol85PreprocessorParserMAP-64))|(1<<(Cobol85PreprocessorParserMARGINS-64))|(1<<(Cobol85PreprocessorParserMD-64))|(1<<(Cobol85PreprocessorParserMDECK-64)))) != 0) || (((_la-97)&-(0x1f+1)) == 0 && ((1<<uint((_la-97)))&((1<<(Cobol85PreprocessorParserNAME-97))|(1<<(Cobol85PreprocessorParserNATLANG-97))|(1<<(Cobol85PreprocessorParserNOADATA-97))|(1<<(Cobol85PreprocessorParserNOADV-97))|(1<<(Cobol85PreprocessorParserNOAWO-97))|(1<<(Cobol85PreprocessorParserNOBLOCK0-97))|(1<<(Cobol85PreprocessorParserNOC-97))|(1<<(Cobol85PreprocessorParserNOCBLCARD-97))|(1<<(Cobol85PreprocessorParserNOCICS-97))|(1<<(Cobol85PreprocessorParserNOCMPR2-97))|(1<<(Cobol85PreprocessorParserNOCOMPILE-97))|(1<<(Cobol85PreprocessorParserNOCPSM-97))|(1<<(Cobol85PreprocessorParserNOCURR-97))|(1<<(Cobol85PreprocessorParserNOCURRENCY-97))|(1<<(Cobol85PreprocessorParserNOD-97))|(1<<(Cobol85PreprocessorParserNODATEPROC-97))|(1<<(Cobol85PreprocessorParserNODBCS-97))|(1<<(Cobol85PreprocessorParserNODE-97))|(1<<(Cobol85PreprocessorParserNODEBUG-97))|(1<<(Cobol85PreprocessorParserNODECK-97))|(1<<(Cobol85PreprocessorParserNODIAGTRUNC-97))|(1<<(Cobol85PreprocessorParserNODLL-97))|(1<<(Cobol85PreprocessorParserNODU-97))|(1<<(Cobol85PreprocessorParserNODUMP-97))|(1<<(Cobol85PreprocessorParserNODP-97))|(1<<(Cobol85PreprocessorParserNODTR-97))|(1<<(Cobol85PreprocessorParserNODYN-97)))) != 0) || (((_la-129)&-(0x1f+1)) == 0 && ((1<<uint((_la-129)))&((1<<(Cobol85PreprocessorParserNODYNAM-129))|(1<<(Cobol85PreprocessorParserNOEDF-129))|(1<<(Cobol85PreprocessorParserNOEPILOG-129))|(1<<(Cobol85PreprocessorParserNOEXIT-129))|(1<<(Cobol85PreprocessorParserNOEXP-129))|(1<<(Cobol85PreprocessorParserNOEXPORTALL-129))|(1<<(Cobol85PreprocessorParserNOF-129))|(1<<(Cobol85PreprocessorParserNOFASTSRT-129))|(1<<(Cobol85PreprocessorParserNOFEPI-129))|(1<<(Cobol85PreprocessorParserNOFLAG-129))|(1<<(Cobol85PreprocessorParserNOFLAGMIG-129))|(1<<(Cobol85PreprocessorParserNOFLAGSTD-129))|(1<<(Cobol85PreprocessorParserNOFSRT-129))|(1<<(Cobol85PreprocessorParserNOGRAPHIC-129))|(1<<(Cobol85PreprocessorParserNOLENGTH-129))|(1<<(Cobol85PreprocessorParserNOLIB-129))|(1<<(Cobol85PreprocessorParserNOLINKAGE-129))|(1<<(Cobol85PreprocessorParserNOLIST-129))|(1<<(Cobol85PreprocessorParserNOMAP-129))|(1<<(Cobol85PreprocessorParserNOMD-129))|(1<<(Cobol85PreprocessorParserNOMDECK-129))|(1<<(Cobol85PreprocessorParserNONAME-129))|(1<<(Cobol85PreprocessorParserNONUM-129))|(1<<(Cobol85PreprocessorParserNONUMBER-129))|(1<<(Cobol85PreprocessorParserNOOBJ-129))|(1<<(Cobol85PreprocessorParserNOOBJECT-129))|(1<<(Cobol85PreprocessorParserNOOFF-129))|(1<<(Cobol85PreprocessorParserNOOFFSET-129))|(1<<(Cobol85PreprocessorParserNOOPSEQUENCE-129))|(1<<(Cobol85PreprocessorParserNOOPT-129)))) != 0) || (((_la-161)&-(0x1f+1)) == 0 && ((1<<uint((_la-161)))&((1<<(Cobol85PreprocessorParserNOOPTIMIZE-161))|(1<<(Cobol85PreprocessorParserNOOPTIONS-161))|(1<<(Cobol85PreprocessorParserNOP-161))|(1<<(Cobol85PreprocessorParserNOPROLOG-161))|(1<<(Cobol85PreprocessorParserNORENT-161))|(1<<(Cobol85PreprocessorParserNOS-161))|(1<<(Cobol85PreprocessorParserNOSEQ-161))|(1<<(Cobol85PreprocessorParserNOSOURCE-161))|(1<<(Cobol85PreprocessorParserNOSPIE-161))|(1<<(Cobol85PreprocessorParserNOSQL-161))|(1<<(Cobol85PreprocessorParserNOSQLC-161))|(1<<(Cobol85PreprocessorParserNOSQLCCSID-161))|(1<<(Cobol85PreprocessorParserNOSSR-161))|(1<<(Cobol85PreprocessorParserNOSSRANGE-161))|(1<<(Cobol85PreprocessorParserNOSTDTRUNC-161))|(1<<(Cobol85PreprocessorParserNOSEQUENCE-161))|(1<<(Cobol85PreprocessorParserNOTERM-161))|(1<<(Cobol85PreprocessorParserNOTERMINAL-161))|(1<<(Cobol85PreprocessorParserNOTEST-161))|(1<<(Cobol85PreprocessorParserNOTHREAD-161))|(1<<(Cobol85PreprocessorParserNOVBREF-161))|(1<<(Cobol85PreprocessorParserNOWD-161))|(1<<(Cobol85PreprocessorParserNOWORD-161))|(1<<(Cobol85PreprocessorParserNOX-161))|(1<<(Cobol85PreprocessorParserNOXREF-161))|(1<<(Cobol85PreprocessorParserNOZWB-161))|(1<<(Cobol85PreprocessorParserNS-161))|(1<<(Cobol85PreprocessorParserNSEQ-161)))) != 0) || (((_la-193)&-(0x1f+1)) == 0 && ((1<<uint((_la-193)))&((1<<(Cobol85PreprocessorParserNSYMBOL-193))|(1<<(Cobol85PreprocessorParserNUM-193))|(1<<(Cobol85PreprocessorParserNUMBER-193))|(1<<(Cobol85PreprocessorParserNUMPROC-193))|(1<<(Cobol85PreprocessorParserOBJ-193))|(1<<(Cobol85PreprocessorParserOBJECT-193))|(1<<(Cobol85PreprocessorParserOFF-193))|(1<<(Cobol85PreprocessorParserOFFSET-193))|(1<<(Cobol85PreprocessorParserOP-193))|(1<<(Cobol85PreprocessorParserOPMARGINS-193))|(1<<(Cobol85PreprocessorParserOPSEQUENCE-193))|(1<<(Cobol85PreprocessorParserOPT-193))|(1<<(Cobol85PreprocessorParserOPTFILE-193))|(1<<(Cobol85PreprocessorParserOPTIMIZE-193))|(1<<(Cobol85PreprocessorParserOPTIONS-193))|(1<<(Cobol85PreprocessorParserOUT-193))|(1<<(Cobol85PreprocessorParserOUTDD-193))|(1<<(Cobol85PreprocessorParserPGMN-193))|(1<<(Cobol85PreprocessorParserPGMNAME-193))|(1<<(Cobol85PreprocessorParserPROLOG-193))|(1<<(Cobol85PreprocessorParserQUOTE-193))|(1<<(Cobol85PreprocessorParserRENT-193))|(1<<(Cobol85PreprocessorParserRMODE-193)))) != 0) || (((_la-226)&-(0x1f+1)) == 0 && ((1<<uint((_la-226)))&((1<<(Cobol85PreprocessorParserSEQ-226))|(1<<(Cobol85PreprocessorParserSEQUENCE-226))|(1<<(Cobol85PreprocessorParserSIZE-226))|(1<<(Cobol85PreprocessorParserSOURCE-226))|(1<<(Cobol85PreprocessorParserSP-226))|(1<<(Cobol85PreprocessorParserSPACE-226))|(1<<(Cobol85PreprocessorParserSPIE-226))|(1<<(Cobol85PreprocessorParserSQL-226))|(1<<(Cobol85PreprocessorParserSQLC-226))|(1<<(Cobol85PreprocessorParserSQLCCSID-226))|(1<<(Cobol85PreprocessorParserSSR-226))|(1<<(Cobol85PreprocessorParserSSRANGE-226))|(1<<(Cobol85PreprocessorParserSYSEIB-226))|(1<<(Cobol85PreprocessorParserSZ-226))|(1<<(Cobol85PreprocessorParserTERM-226))|(1<<(Cobol85PreprocessorParserTERMINAL-226))|(1<<(Cobol85PreprocessorParserTEST-226))|(1<<(Cobol85PreprocessorParserTHREAD-226))|(1<<(Cobol85PreprocessorParserTRUNC-226))|(1<<(Cobol85PreprocessorParserVBREF-226)))) != 0) || (((_la-258)&-(0x1f+1)) == 0 && ((1<<uint((_la-258)))&((1<<(Cobol85PreprocessorParserWD-258))|(1<<(Cobol85PreprocessorParserWORD-258))|(1<<(Cobol85PreprocessorParserXMLPARSE-258))|(1<<(Cobol85PreprocessorParserXP-258))|(1<<(Cobol85PreprocessorParserXREF-258))|(1<<(Cobol85PreprocessorParserYEARWINDOW-258))|(1<<(Cobol85PreprocessorParserYW-258))|(1<<(Cobol85PreprocessorParserZWB-258))|(1<<(Cobol85PreprocessorParserC_CHAR-258))|(1<<(Cobol85PreprocessorParserD_CHAR-258))|(1<<(Cobol85PreprocessorParserF_CHAR-258))|(1<<(Cobol85PreprocessorParserQ_CHAR-258))|(1<<(Cobol85PreprocessorParserS_CHAR-258))|(1<<(Cobol85PreprocessorParserX_CHAR-258))|(1<<(Cobol85PreprocessorParserCOMMACHAR-258)))) != 0) {
		p.SetState(93)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Cobol85PreprocessorParserCOMMACHAR {
			{
				p.SetState(92)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}

		}
		{
			p.SetState(95)
			p.CompilerOption()
		}

		p.SetState(100)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(101)
		p.Match(Cobol85PreprocessorParserRPARENCHAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyCompilerOptionContext() *CompilerOptionContext {
	var p = new(CompilerOptionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerOption
	return p
}

func (*CompilerOptionContext) IsCompilerOptionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_compilerOption

	return p
}

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

func (s *CompilerOptionContext) ADATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserADATA, 0)
}

func (s *CompilerOptionContext) ADV() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserADV, 0)
}

func (s *CompilerOptionContext) APOST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAPOST, 0)
}

func (s *CompilerOptionContext) LPARENCHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLPARENCHAR, 0)
}

func (s *CompilerOptionContext) RPARENCHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRPARENCHAR, 0)
}

func (s *CompilerOptionContext) ARITH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserARITH, 0)
}

func (s *CompilerOptionContext) AR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAR, 0)
}

func (s *CompilerOptionContext) EXTEND() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXTEND, 0)
}

func (s *CompilerOptionContext) AllE_CHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserE_CHAR)
}

func (s *CompilerOptionContext) E_CHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserE_CHAR, i)
}

func (s *CompilerOptionContext) COMPAT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMPAT, 0)
}

func (s *CompilerOptionContext) C_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserC_CHAR, 0)
}

func (s *CompilerOptionContext) AWO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAWO, 0)
}

func (s *CompilerOptionContext) BLOCK0() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBLOCK0, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *CompilerOptionContext) BUFSIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBUFSIZE, 0)
}

func (s *CompilerOptionContext) BUF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBUF, 0)
}

func (s *CompilerOptionContext) CBLCARD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCBLCARD, 0)
}

func (s *CompilerOptionContext) CICS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCICS, 0)
}

func (s *CompilerOptionContext) COBOL2() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOBOL2, 0)
}

func (s *CompilerOptionContext) COBOL3() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOBOL3, 0)
}

func (s *CompilerOptionContext) CODEPAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCODEPAGE, 0)
}

func (s *CompilerOptionContext) CP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCP, 0)
}

func (s *CompilerOptionContext) COMPILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMPILE, 0)
}

func (s *CompilerOptionContext) CPP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCPP, 0)
}

func (s *CompilerOptionContext) CPSM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCPSM, 0)
}

func (s *CompilerOptionContext) CURRENCY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCURRENCY, 0)
}

func (s *CompilerOptionContext) CURR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCURR, 0)
}

func (s *CompilerOptionContext) DATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDATA, 0)
}

func (s *CompilerOptionContext) DATEPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDATEPROC, 0)
}

func (s *CompilerOptionContext) DP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDP, 0)
}

func (s *CompilerOptionContext) AllCOMMACHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserCOMMACHAR)
}

func (s *CompilerOptionContext) COMMACHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMMACHAR, i)
}

func (s *CompilerOptionContext) FLAG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFLAG, 0)
}

func (s *CompilerOptionContext) NOFLAG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAG, 0)
}

func (s *CompilerOptionContext) TRIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTRIG, 0)
}

func (s *CompilerOptionContext) NOTRIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTRIG, 0)
}

func (s *CompilerOptionContext) DBCS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDBCS, 0)
}

func (s *CompilerOptionContext) DECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDECK, 0)
}

func (s *CompilerOptionContext) D_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserD_CHAR, 0)
}

func (s *CompilerOptionContext) DEBUG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDEBUG, 0)
}

func (s *CompilerOptionContext) DIAGTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDIAGTRUNC, 0)
}

func (s *CompilerOptionContext) DTR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDTR, 0)
}

func (s *CompilerOptionContext) DLL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDLL, 0)
}

func (s *CompilerOptionContext) DUMP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDUMP, 0)
}

func (s *CompilerOptionContext) DU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDU, 0)
}

func (s *CompilerOptionContext) DYNAM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDYNAM, 0)
}

func (s *CompilerOptionContext) DYN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDYN, 0)
}

func (s *CompilerOptionContext) EDF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEDF, 0)
}

func (s *CompilerOptionContext) EPILOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEPILOG, 0)
}

func (s *CompilerOptionContext) EXIT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXIT, 0)
}

func (s *CompilerOptionContext) EXPORTALL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXPORTALL, 0)
}

func (s *CompilerOptionContext) EXP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXP, 0)
}

func (s *CompilerOptionContext) FASTSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFASTSRT, 0)
}

func (s *CompilerOptionContext) FSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFSRT, 0)
}

func (s *CompilerOptionContext) FEPI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFEPI, 0)
}

func (s *CompilerOptionContext) F_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserF_CHAR, 0)
}

func (s *CompilerOptionContext) AllI_CHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserI_CHAR)
}

func (s *CompilerOptionContext) I_CHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserI_CHAR, i)
}

func (s *CompilerOptionContext) AllS_CHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserS_CHAR)
}

func (s *CompilerOptionContext) S_CHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserS_CHAR, i)
}

func (s *CompilerOptionContext) AllU_CHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserU_CHAR)
}

func (s *CompilerOptionContext) U_CHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserU_CHAR, i)
}

func (s *CompilerOptionContext) AllW_CHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserW_CHAR)
}

func (s *CompilerOptionContext) W_CHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserW_CHAR, i)
}

func (s *CompilerOptionContext) FLAGSTD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFLAGSTD, 0)
}

func (s *CompilerOptionContext) M_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserM_CHAR, 0)
}

func (s *CompilerOptionContext) H_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserH_CHAR, 0)
}

func (s *CompilerOptionContext) DD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDD, 0)
}

func (s *CompilerOptionContext) N_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserN_CHAR, 0)
}

func (s *CompilerOptionContext) NN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNN, 0)
}

func (s *CompilerOptionContext) SS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSS, 0)
}

func (s *CompilerOptionContext) GDS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserGDS, 0)
}

func (s *CompilerOptionContext) GRAPHIC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserGRAPHIC, 0)
}

func (s *CompilerOptionContext) INTDATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserINTDATE, 0)
}

func (s *CompilerOptionContext) ANSI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserANSI, 0)
}

func (s *CompilerOptionContext) LILIAN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLILIAN, 0)
}

func (s *CompilerOptionContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLANGUAGE, 0)
}

func (s *CompilerOptionContext) LANG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLANG, 0)
}

func (s *CompilerOptionContext) ENGLISH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserENGLISH, 0)
}

func (s *CompilerOptionContext) CS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCS, 0)
}

func (s *CompilerOptionContext) EN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEN, 0)
}

func (s *CompilerOptionContext) JA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserJA, 0)
}

func (s *CompilerOptionContext) JP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserJP, 0)
}

func (s *CompilerOptionContext) KA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserKA, 0)
}

func (s *CompilerOptionContext) UE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserUE, 0)
}

func (s *CompilerOptionContext) LEASM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLEASM, 0)
}

func (s *CompilerOptionContext) LENGTH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLENGTH, 0)
}

func (s *CompilerOptionContext) LIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIB, 0)
}

func (s *CompilerOptionContext) LIN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIN, 0)
}

func (s *CompilerOptionContext) LINECOUNT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLINECOUNT, 0)
}

func (s *CompilerOptionContext) LC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLC, 0)
}

func (s *CompilerOptionContext) LINKAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLINKAGE, 0)
}

func (s *CompilerOptionContext) LIST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIST, 0)
}

func (s *CompilerOptionContext) MAP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMAP, 0)
}

func (s *CompilerOptionContext) MARGINS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMARGINS, 0)
}

func (s *CompilerOptionContext) MDECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMDECK, 0)
}

func (s *CompilerOptionContext) MD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMD, 0)
}

func (s *CompilerOptionContext) NOC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOC, 0)
}

func (s *CompilerOptionContext) NOCOMPILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCOMPILE, 0)
}

func (s *CompilerOptionContext) NAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNAME, 0)
}

func (s *CompilerOptionContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserALIAS, 0)
}

func (s *CompilerOptionContext) NOALIAS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOALIAS, 0)
}

func (s *CompilerOptionContext) NATLANG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNATLANG, 0)
}

func (s *CompilerOptionContext) NOADATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOADATA, 0)
}

func (s *CompilerOptionContext) NOADV() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOADV, 0)
}

func (s *CompilerOptionContext) NOAWO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOAWO, 0)
}

func (s *CompilerOptionContext) NOBLOCK0() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOBLOCK0, 0)
}

func (s *CompilerOptionContext) NOCBLCARD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCBLCARD, 0)
}

func (s *CompilerOptionContext) NOCICS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCICS, 0)
}

func (s *CompilerOptionContext) NOCMPR2() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCMPR2, 0)
}

func (s *CompilerOptionContext) NOCPSM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCPSM, 0)
}

func (s *CompilerOptionContext) NOCURRENCY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCURRENCY, 0)
}

func (s *CompilerOptionContext) NOCURR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCURR, 0)
}

func (s *CompilerOptionContext) NODATEPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODATEPROC, 0)
}

func (s *CompilerOptionContext) NODP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODP, 0)
}

func (s *CompilerOptionContext) NODBCS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODBCS, 0)
}

func (s *CompilerOptionContext) NODEBUG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODEBUG, 0)
}

func (s *CompilerOptionContext) NODECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODECK, 0)
}

func (s *CompilerOptionContext) NOD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOD, 0)
}

func (s *CompilerOptionContext) NODLL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODLL, 0)
}

func (s *CompilerOptionContext) NODE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODE, 0)
}

func (s *CompilerOptionContext) NODUMP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODUMP, 0)
}

func (s *CompilerOptionContext) NODU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODU, 0)
}

func (s *CompilerOptionContext) NODIAGTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODIAGTRUNC, 0)
}

func (s *CompilerOptionContext) NODTR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODTR, 0)
}

func (s *CompilerOptionContext) NODYNAM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODYNAM, 0)
}

func (s *CompilerOptionContext) NODYN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODYN, 0)
}

func (s *CompilerOptionContext) NOEDF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEDF, 0)
}

func (s *CompilerOptionContext) NOEPILOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEPILOG, 0)
}

func (s *CompilerOptionContext) NOEXIT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXIT, 0)
}

func (s *CompilerOptionContext) NOEXPORTALL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXPORTALL, 0)
}

func (s *CompilerOptionContext) NOEXP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXP, 0)
}

func (s *CompilerOptionContext) NOFASTSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFASTSRT, 0)
}

func (s *CompilerOptionContext) NOFSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFSRT, 0)
}

func (s *CompilerOptionContext) NOFEPI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFEPI, 0)
}

func (s *CompilerOptionContext) NOF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOF, 0)
}

func (s *CompilerOptionContext) NOFLAGMIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAGMIG, 0)
}

func (s *CompilerOptionContext) NOFLAGSTD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAGSTD, 0)
}

func (s *CompilerOptionContext) NOGRAPHIC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOGRAPHIC, 0)
}

func (s *CompilerOptionContext) NOLENGTH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLENGTH, 0)
}

func (s *CompilerOptionContext) NOLIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLIB, 0)
}

func (s *CompilerOptionContext) NOLINKAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLINKAGE, 0)
}

func (s *CompilerOptionContext) NOLIST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLIST, 0)
}

func (s *CompilerOptionContext) NOMAP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMAP, 0)
}

func (s *CompilerOptionContext) NOMDECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMDECK, 0)
}

func (s *CompilerOptionContext) NOMD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMD, 0)
}

func (s *CompilerOptionContext) NONAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONAME, 0)
}

func (s *CompilerOptionContext) NONUMBER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONUMBER, 0)
}

func (s *CompilerOptionContext) NONUM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONUM, 0)
}

func (s *CompilerOptionContext) NOOBJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOBJECT, 0)
}

func (s *CompilerOptionContext) NOOBJ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOBJ, 0)
}

func (s *CompilerOptionContext) NOOFFSET() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOFFSET, 0)
}

func (s *CompilerOptionContext) NOOFF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOFF, 0)
}

func (s *CompilerOptionContext) NOOPSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPSEQUENCE, 0)
}

func (s *CompilerOptionContext) NOOPTIMIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPTIMIZE, 0)
}

func (s *CompilerOptionContext) NOOPT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPT, 0)
}

func (s *CompilerOptionContext) NOOPTIONS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPTIONS, 0)
}

func (s *CompilerOptionContext) NOP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOP, 0)
}

func (s *CompilerOptionContext) NOPROLOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOPROLOG, 0)
}

func (s *CompilerOptionContext) NORENT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNORENT, 0)
}

func (s *CompilerOptionContext) NOSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEQUENCE, 0)
}

func (s *CompilerOptionContext) NOSEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEQ, 0)
}

func (s *CompilerOptionContext) NOSOURCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSOURCE, 0)
}

func (s *CompilerOptionContext) NOS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOS, 0)
}

func (s *CompilerOptionContext) NOSPIE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSPIE, 0)
}

func (s *CompilerOptionContext) NOSQL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQL, 0)
}

func (s *CompilerOptionContext) NOSQLCCSID() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQLCCSID, 0)
}

func (s *CompilerOptionContext) NOSQLC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQLC, 0)
}

func (s *CompilerOptionContext) NOSSRANGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSSRANGE, 0)
}

func (s *CompilerOptionContext) NOSSR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSSR, 0)
}

func (s *CompilerOptionContext) NOSTDTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSTDTRUNC, 0)
}

func (s *CompilerOptionContext) NOTERMINAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTERMINAL, 0)
}

func (s *CompilerOptionContext) NOTERM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTERM, 0)
}

func (s *CompilerOptionContext) NOTEST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTEST, 0)
}

func (s *CompilerOptionContext) NOTHREAD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTHREAD, 0)
}

func (s *CompilerOptionContext) NOVBREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOVBREF, 0)
}

func (s *CompilerOptionContext) NOWORD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOWORD, 0)
}

func (s *CompilerOptionContext) NOWD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOWD, 0)
}

func (s *CompilerOptionContext) NSEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNSEQ, 0)
}

func (s *CompilerOptionContext) NSYMBOL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNSYMBOL, 0)
}

func (s *CompilerOptionContext) NS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNS, 0)
}

func (s *CompilerOptionContext) NATIONAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNATIONAL, 0)
}

func (s *CompilerOptionContext) NAT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNAT, 0)
}

func (s *CompilerOptionContext) NOXREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOXREF, 0)
}

func (s *CompilerOptionContext) NOX() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOX, 0)
}

func (s *CompilerOptionContext) NOZWB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOZWB, 0)
}

func (s *CompilerOptionContext) NUMBER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUMBER, 0)
}

func (s *CompilerOptionContext) NUM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUM, 0)
}

func (s *CompilerOptionContext) NUMPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUMPROC, 0)
}

func (s *CompilerOptionContext) MIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMIG, 0)
}

func (s *CompilerOptionContext) NOPFD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOPFD, 0)
}

func (s *CompilerOptionContext) PFD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPFD, 0)
}

func (s *CompilerOptionContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOBJECT, 0)
}

func (s *CompilerOptionContext) OBJ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOBJ, 0)
}

func (s *CompilerOptionContext) OFFSET() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOFFSET, 0)
}

func (s *CompilerOptionContext) OFF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOFF, 0)
}

func (s *CompilerOptionContext) OPMARGINS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPMARGINS, 0)
}

func (s *CompilerOptionContext) OPSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPSEQUENCE, 0)
}

func (s *CompilerOptionContext) OPTIMIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTIMIZE, 0)
}

func (s *CompilerOptionContext) OPT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPT, 0)
}

func (s *CompilerOptionContext) FULL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFULL, 0)
}

func (s *CompilerOptionContext) STD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSTD, 0)
}

func (s *CompilerOptionContext) OPTFILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTFILE, 0)
}

func (s *CompilerOptionContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTIONS, 0)
}

func (s *CompilerOptionContext) OP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOP, 0)
}

func (s *CompilerOptionContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *CompilerOptionContext) OUTDD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOUTDD, 0)
}

func (s *CompilerOptionContext) OUT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOUT, 0)
}

func (s *CompilerOptionContext) PGMNAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPGMNAME, 0)
}

func (s *CompilerOptionContext) PGMN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPGMN, 0)
}

func (s *CompilerOptionContext) CO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCO, 0)
}

func (s *CompilerOptionContext) LM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLM, 0)
}

func (s *CompilerOptionContext) LONGMIXED() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLONGMIXED, 0)
}

func (s *CompilerOptionContext) LONGUPPER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLONGUPPER, 0)
}

func (s *CompilerOptionContext) LU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLU, 0)
}

func (s *CompilerOptionContext) MIXED() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMIXED, 0)
}

func (s *CompilerOptionContext) UPPER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserUPPER, 0)
}

func (s *CompilerOptionContext) PROLOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPROLOG, 0)
}

func (s *CompilerOptionContext) QUOTE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserQUOTE, 0)
}

func (s *CompilerOptionContext) Q_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserQ_CHAR, 0)
}

func (s *CompilerOptionContext) RENT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRENT, 0)
}

func (s *CompilerOptionContext) RMODE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRMODE, 0)
}

func (s *CompilerOptionContext) ANY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserANY, 0)
}

func (s *CompilerOptionContext) AUTO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAUTO, 0)
}

func (s *CompilerOptionContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEQUENCE, 0)
}

func (s *CompilerOptionContext) SEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEQ, 0)
}

func (s *CompilerOptionContext) SIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSIZE, 0)
}

func (s *CompilerOptionContext) SZ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSZ, 0)
}

func (s *CompilerOptionContext) MAX() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMAX, 0)
}

func (s *CompilerOptionContext) SOURCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSOURCE, 0)
}

func (s *CompilerOptionContext) SP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSP, 0)
}

func (s *CompilerOptionContext) SPACE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSPACE, 0)
}

func (s *CompilerOptionContext) SPIE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSPIE, 0)
}

func (s *CompilerOptionContext) SQL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQL, 0)
}

func (s *CompilerOptionContext) SQLCCSID() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQLCCSID, 0)
}

func (s *CompilerOptionContext) SQLC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQLC, 0)
}

func (s *CompilerOptionContext) SSRANGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSSRANGE, 0)
}

func (s *CompilerOptionContext) SSR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSSR, 0)
}

func (s *CompilerOptionContext) SYSEIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSYSEIB, 0)
}

func (s *CompilerOptionContext) TERMINAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTERMINAL, 0)
}

func (s *CompilerOptionContext) TERM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTERM, 0)
}

func (s *CompilerOptionContext) TEST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTEST, 0)
}

func (s *CompilerOptionContext) HOOK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserHOOK, 0)
}

func (s *CompilerOptionContext) NOHOOK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOHOOK, 0)
}

func (s *CompilerOptionContext) SEP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEP, 0)
}

func (s *CompilerOptionContext) SEPARATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEPARATE, 0)
}

func (s *CompilerOptionContext) NOSEP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEP, 0)
}

func (s *CompilerOptionContext) NOSEPARATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEPARATE, 0)
}

func (s *CompilerOptionContext) EJPD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEJPD, 0)
}

func (s *CompilerOptionContext) NOEJPD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEJPD, 0)
}

func (s *CompilerOptionContext) THREAD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTHREAD, 0)
}

func (s *CompilerOptionContext) TRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTRUNC, 0)
}

func (s *CompilerOptionContext) BIN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBIN, 0)
}

func (s *CompilerOptionContext) VBREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserVBREF, 0)
}

func (s *CompilerOptionContext) WORD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserWORD, 0)
}

func (s *CompilerOptionContext) WD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserWD, 0)
}

func (s *CompilerOptionContext) XMLPARSE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXMLPARSE, 0)
}

func (s *CompilerOptionContext) XP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXP, 0)
}

func (s *CompilerOptionContext) XMLSS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXMLSS, 0)
}

func (s *CompilerOptionContext) X_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserX_CHAR, 0)
}

func (s *CompilerOptionContext) XREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXREF, 0)
}

func (s *CompilerOptionContext) SHORT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSHORT, 0)
}

func (s *CompilerOptionContext) YEARWINDOW() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserYEARWINDOW, 0)
}

func (s *CompilerOptionContext) YW() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserYW, 0)
}

func (s *CompilerOptionContext) ZWB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserZWB, 0)
}

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

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

func (s *CompilerOptionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCompilerOption(s)
	}
}

func (s *CompilerOptionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCompilerOption(s)
	}
}

func (p *Cobol85PreprocessorParser) CompilerOption() (localctx ICompilerOptionContext) {
	localctx = NewCompilerOptionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, Cobol85PreprocessorParserRULE_compilerOption)
	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(445)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 32, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(103)
			p.Match(Cobol85PreprocessorParserADATA)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(104)
			p.Match(Cobol85PreprocessorParserADV)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(105)
			p.Match(Cobol85PreprocessorParserAPOST)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(106)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserAR || _la == Cobol85PreprocessorParserARITH) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(107)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(108)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCOMPAT || _la == Cobol85PreprocessorParserEXTEND || _la == Cobol85PreprocessorParserC_CHAR || _la == Cobol85PreprocessorParserE_CHAR) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(109)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(110)
			p.Match(Cobol85PreprocessorParserAWO)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(111)
			p.Match(Cobol85PreprocessorParserBLOCK0)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(112)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserBUF || _la == Cobol85PreprocessorParserBUFSIZE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(113)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(114)
			p.Literal()
		}
		{
			p.SetState(115)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(117)
			p.Match(Cobol85PreprocessorParserCBLCARD)
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(118)
			p.Match(Cobol85PreprocessorParserCICS)
		}
		p.SetState(123)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(119)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(120)
				p.Literal()
			}
			{
				p.SetState(121)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(125)
			p.Match(Cobol85PreprocessorParserCOBOL2)
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(126)
			p.Match(Cobol85PreprocessorParserCOBOL3)
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(127)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCODEPAGE || _la == Cobol85PreprocessorParserCP) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(128)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(129)
			p.Literal()
		}
		{
			p.SetState(130)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(132)
			_la = p.GetTokenStream().LA(1)

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

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(133)
			p.Match(Cobol85PreprocessorParserCPP)
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(134)
			p.Match(Cobol85PreprocessorParserCPSM)
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(135)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCURR || _la == Cobol85PreprocessorParserCURRENCY) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(136)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(137)
			p.Literal()
		}
		{
			p.SetState(138)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(140)
			p.Match(Cobol85PreprocessorParserDATA)
		}
		{
			p.SetState(141)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(142)
			p.Literal()
		}
		{
			p.SetState(143)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(145)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserDATEPROC || _la == Cobol85PreprocessorParserDP) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(157)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(146)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			p.SetState(148)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == Cobol85PreprocessorParserFLAG || _la == Cobol85PreprocessorParserNOFLAG {
				{
					p.SetState(147)
					_la = p.GetTokenStream().LA(1)

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

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

			if _la == Cobol85PreprocessorParserCOMMACHAR {
				{
					p.SetState(150)
					p.Match(Cobol85PreprocessorParserCOMMACHAR)
				}

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

			if _la == Cobol85PreprocessorParserNOTRIG || _la == Cobol85PreprocessorParserTRIG {
				{
					p.SetState(153)
					_la = p.GetTokenStream().LA(1)

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

			}
			{
				p.SetState(156)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(159)
			p.Match(Cobol85PreprocessorParserDBCS)
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(160)
			_la = p.GetTokenStream().LA(1)

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

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(161)
			p.Match(Cobol85PreprocessorParserDEBUG)
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(162)
			_la = p.GetTokenStream().LA(1)

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

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(163)
			p.Match(Cobol85PreprocessorParserDLL)
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(164)
			_la = p.GetTokenStream().LA(1)

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

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(165)
			_la = p.GetTokenStream().LA(1)

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

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(166)
			p.Match(Cobol85PreprocessorParserEDF)
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(167)
			p.Match(Cobol85PreprocessorParserEPILOG)
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(168)
			p.Match(Cobol85PreprocessorParserEXIT)
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(169)
			_la = p.GetTokenStream().LA(1)

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

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(170)
			_la = p.GetTokenStream().LA(1)

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

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(171)
			p.Match(Cobol85PreprocessorParserFEPI)
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(172)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserFLAG || _la == Cobol85PreprocessorParserF_CHAR) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(173)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(174)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-270)&-(0x1f+1)) == 0 && ((1<<uint((_la-270)))&((1<<(Cobol85PreprocessorParserE_CHAR-270))|(1<<(Cobol85PreprocessorParserI_CHAR-270))|(1<<(Cobol85PreprocessorParserS_CHAR-270))|(1<<(Cobol85PreprocessorParserU_CHAR-270))|(1<<(Cobol85PreprocessorParserW_CHAR-270)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(177)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Cobol85PreprocessorParserCOMMACHAR {
			{
				p.SetState(175)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}
			{
				p.SetState(176)
				_la = p.GetTokenStream().LA(1)

				if !(((_la-270)&-(0x1f+1)) == 0 && ((1<<uint((_la-270)))&((1<<(Cobol85PreprocessorParserE_CHAR-270))|(1<<(Cobol85PreprocessorParserI_CHAR-270))|(1<<(Cobol85PreprocessorParserS_CHAR-270))|(1<<(Cobol85PreprocessorParserU_CHAR-270))|(1<<(Cobol85PreprocessorParserW_CHAR-270)))) != 0) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(179)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(180)
			p.Match(Cobol85PreprocessorParserFLAGSTD)
		}
		{
			p.SetState(181)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(182)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-272)&-(0x1f+1)) == 0 && ((1<<uint((_la-272)))&((1<<(Cobol85PreprocessorParserH_CHAR-272))|(1<<(Cobol85PreprocessorParserI_CHAR-272))|(1<<(Cobol85PreprocessorParserM_CHAR-272)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(185)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Cobol85PreprocessorParserCOMMACHAR {
			{
				p.SetState(183)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}
			{
				p.SetState(184)
				_la = p.GetTokenStream().LA(1)

				if !(_la == Cobol85PreprocessorParserDD || _la == Cobol85PreprocessorParserNN || _la == Cobol85PreprocessorParserSS || _la == Cobol85PreprocessorParserD_CHAR || _la == Cobol85PreprocessorParserN_CHAR || _la == Cobol85PreprocessorParserS_CHAR) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(187)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(188)
			p.Match(Cobol85PreprocessorParserGDS)
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(189)
			p.Match(Cobol85PreprocessorParserGRAPHIC)
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(190)
			p.Match(Cobol85PreprocessorParserINTDATE)
		}
		{
			p.SetState(191)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(192)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserANSI || _la == Cobol85PreprocessorParserLILIAN) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(193)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(194)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserLANG || _la == Cobol85PreprocessorParserLANGUAGE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(195)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(196)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCS || (((_la-50)&-(0x1f+1)) == 0 && ((1<<uint((_la-50)))&((1<<(Cobol85PreprocessorParserEN-50))|(1<<(Cobol85PreprocessorParserENGLISH-50))|(1<<(Cobol85PreprocessorParserJA-50))|(1<<(Cobol85PreprocessorParserJP-50))|(1<<(Cobol85PreprocessorParserKA-50)))) != 0) || _la == Cobol85PreprocessorParserUE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(197)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 38:
		p.EnterOuterAlt(localctx, 38)
		{
			p.SetState(198)
			p.Match(Cobol85PreprocessorParserLEASM)
		}

	case 39:
		p.EnterOuterAlt(localctx, 39)
		{
			p.SetState(199)
			p.Match(Cobol85PreprocessorParserLENGTH)
		}

	case 40:
		p.EnterOuterAlt(localctx, 40)
		{
			p.SetState(200)
			p.Match(Cobol85PreprocessorParserLIB)
		}

	case 41:
		p.EnterOuterAlt(localctx, 41)
		{
			p.SetState(201)
			p.Match(Cobol85PreprocessorParserLIN)
		}

	case 42:
		p.EnterOuterAlt(localctx, 42)
		{
			p.SetState(202)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserLC || _la == Cobol85PreprocessorParserLINECOUNT) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(203)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(204)
			p.Literal()
		}
		{
			p.SetState(205)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 43:
		p.EnterOuterAlt(localctx, 43)
		{
			p.SetState(207)
			p.Match(Cobol85PreprocessorParserLINKAGE)
		}

	case 44:
		p.EnterOuterAlt(localctx, 44)
		{
			p.SetState(208)
			p.Match(Cobol85PreprocessorParserLIST)
		}

	case 45:
		p.EnterOuterAlt(localctx, 45)
		{
			p.SetState(209)
			p.Match(Cobol85PreprocessorParserMAP)
		}

	case 46:
		p.EnterOuterAlt(localctx, 46)
		{
			p.SetState(210)
			p.Match(Cobol85PreprocessorParserMARGINS)
		}
		{
			p.SetState(211)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(212)
			p.Literal()
		}
		{
			p.SetState(213)
			p.Match(Cobol85PreprocessorParserCOMMACHAR)
		}
		{
			p.SetState(214)
			p.Literal()
		}
		p.SetState(217)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Cobol85PreprocessorParserCOMMACHAR {
			{
				p.SetState(215)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}
			{
				p.SetState(216)
				p.Literal()
			}

		}
		{
			p.SetState(219)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 47:
		p.EnterOuterAlt(localctx, 47)
		{
			p.SetState(221)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserMD || _la == Cobol85PreprocessorParserMDECK) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(225)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(222)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(223)
				_la = p.GetTokenStream().LA(1)

				if !(_la == Cobol85PreprocessorParserCOMPILE || _la == Cobol85PreprocessorParserNOC || _la == Cobol85PreprocessorParserNOCOMPILE || _la == Cobol85PreprocessorParserC_CHAR) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(224)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 48:
		p.EnterOuterAlt(localctx, 48)
		{
			p.SetState(227)
			p.Match(Cobol85PreprocessorParserNAME)
		}
		p.SetState(231)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(228)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(229)
				_la = p.GetTokenStream().LA(1)

				if !(_la == Cobol85PreprocessorParserALIAS || _la == Cobol85PreprocessorParserNOALIAS) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(230)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 49:
		p.EnterOuterAlt(localctx, 49)
		{
			p.SetState(233)
			p.Match(Cobol85PreprocessorParserNATLANG)
		}
		{
			p.SetState(234)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(235)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCS || _la == Cobol85PreprocessorParserEN || _la == Cobol85PreprocessorParserKA) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(236)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 50:
		p.EnterOuterAlt(localctx, 50)
		{
			p.SetState(237)
			p.Match(Cobol85PreprocessorParserNOADATA)
		}

	case 51:
		p.EnterOuterAlt(localctx, 51)
		{
			p.SetState(238)
			p.Match(Cobol85PreprocessorParserNOADV)
		}

	case 52:
		p.EnterOuterAlt(localctx, 52)
		{
			p.SetState(239)
			p.Match(Cobol85PreprocessorParserNOAWO)
		}

	case 53:
		p.EnterOuterAlt(localctx, 53)
		{
			p.SetState(240)
			p.Match(Cobol85PreprocessorParserNOBLOCK0)
		}

	case 54:
		p.EnterOuterAlt(localctx, 54)
		{
			p.SetState(241)
			p.Match(Cobol85PreprocessorParserNOCBLCARD)
		}

	case 55:
		p.EnterOuterAlt(localctx, 55)
		{
			p.SetState(242)
			p.Match(Cobol85PreprocessorParserNOCICS)
		}

	case 56:
		p.EnterOuterAlt(localctx, 56)
		{
			p.SetState(243)
			p.Match(Cobol85PreprocessorParserNOCMPR2)
		}

	case 57:
		p.EnterOuterAlt(localctx, 57)
		{
			p.SetState(244)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserNOC || _la == Cobol85PreprocessorParserNOCOMPILE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(248)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(245)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(246)
				_la = p.GetTokenStream().LA(1)

				if !(((_la-270)&-(0x1f+1)) == 0 && ((1<<uint((_la-270)))&((1<<(Cobol85PreprocessorParserE_CHAR-270))|(1<<(Cobol85PreprocessorParserS_CHAR-270))|(1<<(Cobol85PreprocessorParserW_CHAR-270)))) != 0) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(247)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 58:
		p.EnterOuterAlt(localctx, 58)
		{
			p.SetState(250)
			p.Match(Cobol85PreprocessorParserNOCPSM)
		}

	case 59:
		p.EnterOuterAlt(localctx, 59)
		{
			p.SetState(251)
			_la = p.GetTokenStream().LA(1)

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

	case 60:
		p.EnterOuterAlt(localctx, 60)
		{
			p.SetState(252)
			_la = p.GetTokenStream().LA(1)

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

	case 61:
		p.EnterOuterAlt(localctx, 61)
		{
			p.SetState(253)
			p.Match(Cobol85PreprocessorParserNODBCS)
		}

	case 62:
		p.EnterOuterAlt(localctx, 62)
		{
			p.SetState(254)
			p.Match(Cobol85PreprocessorParserNODEBUG)
		}

	case 63:
		p.EnterOuterAlt(localctx, 63)
		{
			p.SetState(255)
			_la = p.GetTokenStream().LA(1)

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

	case 64:
		p.EnterOuterAlt(localctx, 64)
		{
			p.SetState(256)
			p.Match(Cobol85PreprocessorParserNODLL)
		}

	case 65:
		p.EnterOuterAlt(localctx, 65)
		{
			p.SetState(257)
			p.Match(Cobol85PreprocessorParserNODE)
		}

	case 66:
		p.EnterOuterAlt(localctx, 66)
		{
			p.SetState(258)
			_la = p.GetTokenStream().LA(1)

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

	case 67:
		p.EnterOuterAlt(localctx, 67)
		{
			p.SetState(259)
			_la = p.GetTokenStream().LA(1)

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

	case 68:
		p.EnterOuterAlt(localctx, 68)
		{
			p.SetState(260)
			_la = p.GetTokenStream().LA(1)

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

	case 69:
		p.EnterOuterAlt(localctx, 69)
		{
			p.SetState(261)
			p.Match(Cobol85PreprocessorParserNOEDF)
		}

	case 70:
		p.EnterOuterAlt(localctx, 70)
		{
			p.SetState(262)
			p.Match(Cobol85PreprocessorParserNOEPILOG)
		}

	case 71:
		p.EnterOuterAlt(localctx, 71)
		{
			p.SetState(263)
			p.Match(Cobol85PreprocessorParserNOEXIT)
		}

	case 72:
		p.EnterOuterAlt(localctx, 72)
		{
			p.SetState(264)
			_la = p.GetTokenStream().LA(1)

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

	case 73:
		p.EnterOuterAlt(localctx, 73)
		{
			p.SetState(265)
			_la = p.GetTokenStream().LA(1)

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

	case 74:
		p.EnterOuterAlt(localctx, 74)
		{
			p.SetState(266)
			p.Match(Cobol85PreprocessorParserNOFEPI)
		}

	case 75:
		p.EnterOuterAlt(localctx, 75)
		{
			p.SetState(267)
			_la = p.GetTokenStream().LA(1)

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

	case 76:
		p.EnterOuterAlt(localctx, 76)
		{
			p.SetState(268)
			p.Match(Cobol85PreprocessorParserNOFLAGMIG)
		}

	case 77:
		p.EnterOuterAlt(localctx, 77)
		{
			p.SetState(269)
			p.Match(Cobol85PreprocessorParserNOFLAGSTD)
		}

	case 78:
		p.EnterOuterAlt(localctx, 78)
		{
			p.SetState(270)
			p.Match(Cobol85PreprocessorParserNOGRAPHIC)
		}

	case 79:
		p.EnterOuterAlt(localctx, 79)
		{
			p.SetState(271)
			p.Match(Cobol85PreprocessorParserNOLENGTH)
		}

	case 80:
		p.EnterOuterAlt(localctx, 80)
		{
			p.SetState(272)
			p.Match(Cobol85PreprocessorParserNOLIB)
		}

	case 81:
		p.EnterOuterAlt(localctx, 81)
		{
			p.SetState(273)
			p.Match(Cobol85PreprocessorParserNOLINKAGE)
		}

	case 82:
		p.EnterOuterAlt(localctx, 82)
		{
			p.SetState(274)
			p.Match(Cobol85PreprocessorParserNOLIST)
		}

	case 83:
		p.EnterOuterAlt(localctx, 83)
		{
			p.SetState(275)
			p.Match(Cobol85PreprocessorParserNOMAP)
		}

	case 84:
		p.EnterOuterAlt(localctx, 84)
		{
			p.SetState(276)
			_la = p.GetTokenStream().LA(1)

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

	case 85:
		p.EnterOuterAlt(localctx, 85)
		{
			p.SetState(277)
			p.Match(Cobol85PreprocessorParserNONAME)
		}

	case 86:
		p.EnterOuterAlt(localctx, 86)
		{
			p.SetState(278)
			_la = p.GetTokenStream().LA(1)

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

	case 87:
		p.EnterOuterAlt(localctx, 87)
		{
			p.SetState(279)
			_la = p.GetTokenStream().LA(1)

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

	case 88:
		p.EnterOuterAlt(localctx, 88)
		{
			p.SetState(280)
			_la = p.GetTokenStream().LA(1)

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

	case 89:
		p.EnterOuterAlt(localctx, 89)
		{
			p.SetState(281)
			p.Match(Cobol85PreprocessorParserNOOPSEQUENCE)
		}

	case 90:
		p.EnterOuterAlt(localctx, 90)
		{
			p.SetState(282)
			_la = p.GetTokenStream().LA(1)

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

	case 91:
		p.EnterOuterAlt(localctx, 91)
		{
			p.SetState(283)
			p.Match(Cobol85PreprocessorParserNOOPTIONS)
		}

	case 92:
		p.EnterOuterAlt(localctx, 92)
		{
			p.SetState(284)
			p.Match(Cobol85PreprocessorParserNOP)
		}

	case 93:
		p.EnterOuterAlt(localctx, 93)
		{
			p.SetState(285)
			p.Match(Cobol85PreprocessorParserNOPROLOG)
		}

	case 94:
		p.EnterOuterAlt(localctx, 94)
		{
			p.SetState(286)
			p.Match(Cobol85PreprocessorParserNORENT)
		}

	case 95:
		p.EnterOuterAlt(localctx, 95)
		{
			p.SetState(287)
			_la = p.GetTokenStream().LA(1)

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

	case 96:
		p.EnterOuterAlt(localctx, 96)
		{
			p.SetState(288)
			_la = p.GetTokenStream().LA(1)

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

	case 97:
		p.EnterOuterAlt(localctx, 97)
		{
			p.SetState(289)
			p.Match(Cobol85PreprocessorParserNOSPIE)
		}

	case 98:
		p.EnterOuterAlt(localctx, 98)
		{
			p.SetState(290)
			p.Match(Cobol85PreprocessorParserNOSQL)
		}

	case 99:
		p.EnterOuterAlt(localctx, 99)
		{
			p.SetState(291)
			_la = p.GetTokenStream().LA(1)

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

	case 100:
		p.EnterOuterAlt(localctx, 100)
		{
			p.SetState(292)
			_la = p.GetTokenStream().LA(1)

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

	case 101:
		p.EnterOuterAlt(localctx, 101)
		{
			p.SetState(293)
			p.Match(Cobol85PreprocessorParserNOSTDTRUNC)
		}

	case 102:
		p.EnterOuterAlt(localctx, 102)
		{
			p.SetState(294)
			_la = p.GetTokenStream().LA(1)

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

	case 103:
		p.EnterOuterAlt(localctx, 103)
		{
			p.SetState(295)
			p.Match(Cobol85PreprocessorParserNOTEST)
		}

	case 104:
		p.EnterOuterAlt(localctx, 104)
		{
			p.SetState(296)
			p.Match(Cobol85PreprocessorParserNOTHREAD)
		}

	case 105:
		p.EnterOuterAlt(localctx, 105)
		{
			p.SetState(297)
			p.Match(Cobol85PreprocessorParserNOVBREF)
		}

	case 106:
		p.EnterOuterAlt(localctx, 106)
		{
			p.SetState(298)
			_la = p.GetTokenStream().LA(1)

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

	case 107:
		p.EnterOuterAlt(localctx, 107)
		{
			p.SetState(299)
			p.Match(Cobol85PreprocessorParserNSEQ)
		}

	case 108:
		p.EnterOuterAlt(localctx, 108)
		{
			p.SetState(300)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserNS || _la == Cobol85PreprocessorParserNSYMBOL) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(301)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(302)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserDBCS || _la == Cobol85PreprocessorParserNAT || _la == Cobol85PreprocessorParserNATIONAL) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(303)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 109:
		p.EnterOuterAlt(localctx, 109)
		{
			p.SetState(304)
			p.Match(Cobol85PreprocessorParserNOVBREF)
		}

	case 110:
		p.EnterOuterAlt(localctx, 110)
		{
			p.SetState(305)
			_la = p.GetTokenStream().LA(1)

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

	case 111:
		p.EnterOuterAlt(localctx, 111)
		{
			p.SetState(306)
			p.Match(Cobol85PreprocessorParserNOZWB)
		}

	case 112:
		p.EnterOuterAlt(localctx, 112)
		{
			p.SetState(307)
			_la = p.GetTokenStream().LA(1)

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

	case 113:
		p.EnterOuterAlt(localctx, 113)
		{
			p.SetState(308)
			p.Match(Cobol85PreprocessorParserNUMPROC)
		}
		{
			p.SetState(309)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(310)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserMIG || _la == Cobol85PreprocessorParserNOPFD || _la == Cobol85PreprocessorParserPFD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(311)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 114:
		p.EnterOuterAlt(localctx, 114)
		{
			p.SetState(312)
			_la = p.GetTokenStream().LA(1)

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

	case 115:
		p.EnterOuterAlt(localctx, 115)
		{
			p.SetState(313)
			_la = p.GetTokenStream().LA(1)

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

	case 116:
		p.EnterOuterAlt(localctx, 116)
		{
			p.SetState(314)
			p.Match(Cobol85PreprocessorParserOPMARGINS)
		}
		{
			p.SetState(315)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(316)
			p.Literal()
		}
		{
			p.SetState(317)
			p.Match(Cobol85PreprocessorParserCOMMACHAR)
		}
		{
			p.SetState(318)
			p.Literal()
		}
		p.SetState(321)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Cobol85PreprocessorParserCOMMACHAR {
			{
				p.SetState(319)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}
			{
				p.SetState(320)
				p.Literal()
			}

		}
		{
			p.SetState(323)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 117:
		p.EnterOuterAlt(localctx, 117)
		{
			p.SetState(325)
			p.Match(Cobol85PreprocessorParserOPSEQUENCE)
		}
		{
			p.SetState(326)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(327)
			p.Literal()
		}
		{
			p.SetState(328)
			p.Match(Cobol85PreprocessorParserCOMMACHAR)
		}
		{
			p.SetState(329)
			p.Literal()
		}
		{
			p.SetState(330)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 118:
		p.EnterOuterAlt(localctx, 118)
		{
			p.SetState(332)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserOPT || _la == Cobol85PreprocessorParserOPTIMIZE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(336)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(333)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(334)
				_la = p.GetTokenStream().LA(1)

				if !(_la == Cobol85PreprocessorParserFULL || _la == Cobol85PreprocessorParserSTD) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(335)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 119:
		p.EnterOuterAlt(localctx, 119)
		{
			p.SetState(338)
			p.Match(Cobol85PreprocessorParserOPTFILE)
		}

	case 120:
		p.EnterOuterAlt(localctx, 120)
		{
			p.SetState(339)
			p.Match(Cobol85PreprocessorParserOPTIONS)
		}

	case 121:
		p.EnterOuterAlt(localctx, 121)
		{
			p.SetState(340)
			p.Match(Cobol85PreprocessorParserOP)
		}

	case 122:
		p.EnterOuterAlt(localctx, 122)
		{
			p.SetState(341)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserOUT || _la == Cobol85PreprocessorParserOUTDD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(342)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(343)
			p.CobolWord()
		}
		{
			p.SetState(344)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 123:
		p.EnterOuterAlt(localctx, 123)
		{
			p.SetState(346)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserPGMN || _la == Cobol85PreprocessorParserPGMNAME) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(347)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(348)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCO || _la == Cobol85PreprocessorParserCOMPAT || (((_la-85)&-(0x1f+1)) == 0 && ((1<<uint((_la-85)))&((1<<(Cobol85PreprocessorParserLM-85))|(1<<(Cobol85PreprocessorParserLONGMIXED-85))|(1<<(Cobol85PreprocessorParserLONGUPPER-85))|(1<<(Cobol85PreprocessorParserLU-85))|(1<<(Cobol85PreprocessorParserMIXED-85)))) != 0) || (((_la-256)&-(0x1f+1)) == 0 && ((1<<uint((_la-256)))&((1<<(Cobol85PreprocessorParserUPPER-256))|(1<<(Cobol85PreprocessorParserM_CHAR-256))|(1<<(Cobol85PreprocessorParserU_CHAR-256)))) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(349)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 124:
		p.EnterOuterAlt(localctx, 124)
		{
			p.SetState(350)
			p.Match(Cobol85PreprocessorParserPROLOG)
		}

	case 125:
		p.EnterOuterAlt(localctx, 125)
		{
			p.SetState(351)
			_la = p.GetTokenStream().LA(1)

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

	case 126:
		p.EnterOuterAlt(localctx, 126)
		{
			p.SetState(352)
			p.Match(Cobol85PreprocessorParserRENT)
		}

	case 127:
		p.EnterOuterAlt(localctx, 127)
		{
			p.SetState(353)
			p.Match(Cobol85PreprocessorParserRMODE)
		}
		{
			p.SetState(354)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		p.SetState(358)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case Cobol85PreprocessorParserANY:
			{
				p.SetState(355)
				p.Match(Cobol85PreprocessorParserANY)
			}

		case Cobol85PreprocessorParserAUTO:
			{
				p.SetState(356)
				p.Match(Cobol85PreprocessorParserAUTO)
			}

		case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
			{
				p.SetState(357)
				p.Literal()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(360)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 128:
		p.EnterOuterAlt(localctx, 128)
		{
			p.SetState(361)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserSEQ || _la == Cobol85PreprocessorParserSEQUENCE) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(368)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(362)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(363)
				p.Literal()
			}
			{
				p.SetState(364)
				p.Match(Cobol85PreprocessorParserCOMMACHAR)
			}
			{
				p.SetState(365)
				p.Literal()
			}
			{
				p.SetState(366)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 129:
		p.EnterOuterAlt(localctx, 129)
		{
			p.SetState(370)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserSIZE || _la == Cobol85PreprocessorParserSZ) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(371)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		p.SetState(374)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case Cobol85PreprocessorParserMAX:
			{
				p.SetState(372)
				p.Match(Cobol85PreprocessorParserMAX)
			}

		case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
			{
				p.SetState(373)
				p.Literal()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(376)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 130:
		p.EnterOuterAlt(localctx, 130)
		{
			p.SetState(377)
			_la = p.GetTokenStream().LA(1)

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

	case 131:
		p.EnterOuterAlt(localctx, 131)
		{
			p.SetState(378)
			p.Match(Cobol85PreprocessorParserSP)
		}

	case 132:
		p.EnterOuterAlt(localctx, 132)
		{
			p.SetState(379)
			p.Match(Cobol85PreprocessorParserSPACE)
		}
		{
			p.SetState(380)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(381)
			p.Literal()
		}
		{
			p.SetState(382)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 133:
		p.EnterOuterAlt(localctx, 133)
		{
			p.SetState(384)
			p.Match(Cobol85PreprocessorParserSPIE)
		}

	case 134:
		p.EnterOuterAlt(localctx, 134)
		{
			p.SetState(385)
			p.Match(Cobol85PreprocessorParserSQL)
		}
		p.SetState(390)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(386)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			{
				p.SetState(387)
				p.Literal()
			}
			{
				p.SetState(388)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 135:
		p.EnterOuterAlt(localctx, 135)
		{
			p.SetState(392)
			_la = p.GetTokenStream().LA(1)

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

	case 136:
		p.EnterOuterAlt(localctx, 136)
		{
			p.SetState(393)
			_la = p.GetTokenStream().LA(1)

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

	case 137:
		p.EnterOuterAlt(localctx, 137)
		{
			p.SetState(394)
			p.Match(Cobol85PreprocessorParserSYSEIB)
		}

	case 138:
		p.EnterOuterAlt(localctx, 138)
		{
			p.SetState(395)
			_la = p.GetTokenStream().LA(1)

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

	case 139:
		p.EnterOuterAlt(localctx, 139)
		{
			p.SetState(396)
			p.Match(Cobol85PreprocessorParserTEST)
		}
		p.SetState(414)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(397)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			p.SetState(399)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == Cobol85PreprocessorParserHOOK || _la == Cobol85PreprocessorParserNOHOOK {
				{
					p.SetState(398)
					_la = p.GetTokenStream().LA(1)

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

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

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(401)
					p.Match(Cobol85PreprocessorParserCOMMACHAR)
				}

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

			if _la == Cobol85PreprocessorParserNOSEP || _la == Cobol85PreprocessorParserNOSEPARATE || _la == Cobol85PreprocessorParserSEP || _la == Cobol85PreprocessorParserSEPARATE {
				{
					p.SetState(404)
					_la = p.GetTokenStream().LA(1)

					if !(_la == Cobol85PreprocessorParserNOSEP || _la == Cobol85PreprocessorParserNOSEPARATE || _la == Cobol85PreprocessorParserSEP || _la == Cobol85PreprocessorParserSEPARATE) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}

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

			if _la == Cobol85PreprocessorParserCOMMACHAR {
				{
					p.SetState(407)
					p.Match(Cobol85PreprocessorParserCOMMACHAR)
				}

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

			if _la == Cobol85PreprocessorParserEJPD || _la == Cobol85PreprocessorParserNOEJPD {
				{
					p.SetState(410)
					_la = p.GetTokenStream().LA(1)

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

			}
			{
				p.SetState(413)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 140:
		p.EnterOuterAlt(localctx, 140)
		{
			p.SetState(416)
			p.Match(Cobol85PreprocessorParserTHREAD)
		}

	case 141:
		p.EnterOuterAlt(localctx, 141)
		{
			p.SetState(417)
			p.Match(Cobol85PreprocessorParserTRUNC)
		}
		{
			p.SetState(418)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(419)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserBIN || _la == Cobol85PreprocessorParserOPT || _la == Cobol85PreprocessorParserSTD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(420)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 142:
		p.EnterOuterAlt(localctx, 142)
		{
			p.SetState(421)
			p.Match(Cobol85PreprocessorParserVBREF)
		}

	case 143:
		p.EnterOuterAlt(localctx, 143)
		{
			p.SetState(422)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserWD || _la == Cobol85PreprocessorParserWORD) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(423)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(424)
			p.CobolWord()
		}
		{
			p.SetState(425)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 144:
		p.EnterOuterAlt(localctx, 144)
		{
			p.SetState(427)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserXMLPARSE || _la == Cobol85PreprocessorParserXP) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(428)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(429)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserCOMPAT || (((_la-261)&-(0x1f+1)) == 0 && ((1<<uint((_la-261)))&((1<<(Cobol85PreprocessorParserXMLSS-261))|(1<<(Cobol85PreprocessorParserC_CHAR-261))|(1<<(Cobol85PreprocessorParserX_CHAR-261)))) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(430)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 145:
		p.EnterOuterAlt(localctx, 145)
		{
			p.SetState(431)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserXREF || _la == Cobol85PreprocessorParserX_CHAR) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		p.SetState(437)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(432)
				p.Match(Cobol85PreprocessorParserLPARENCHAR)
			}
			p.SetState(434)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == Cobol85PreprocessorParserFULL || _la == Cobol85PreprocessorParserSHORT {
				{
					p.SetState(433)
					_la = p.GetTokenStream().LA(1)

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

			}
			{
				p.SetState(436)
				p.Match(Cobol85PreprocessorParserRPARENCHAR)
			}

		}

	case 146:
		p.EnterOuterAlt(localctx, 146)
		{
			p.SetState(439)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserYEARWINDOW || _la == Cobol85PreprocessorParserYW) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(440)
			p.Match(Cobol85PreprocessorParserLPARENCHAR)
		}
		{
			p.SetState(441)
			p.Literal()
		}
		{
			p.SetState(442)
			p.Match(Cobol85PreprocessorParserRPARENCHAR)
		}

	case 147:
		p.EnterOuterAlt(localctx, 147)
		{
			p.SetState(444)
			p.Match(Cobol85PreprocessorParserZWB)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExecCicsStatementContext() *ExecCicsStatementContext {
	var p = new(ExecCicsStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_execCicsStatement
	return p
}

func (*ExecCicsStatementContext) IsExecCicsStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_execCicsStatement

	return p
}

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

func (s *ExecCicsStatementContext) EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXEC, 0)
}

func (s *ExecCicsStatementContext) CICS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCICS, 0)
}

func (s *ExecCicsStatementContext) CharData() ICharDataContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataContext)
}

func (s *ExecCicsStatementContext) END_EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEND_EXEC, 0)
}

func (s *ExecCicsStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *ExecCicsStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterExecCicsStatement(s)
	}
}

func (s *ExecCicsStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitExecCicsStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) ExecCicsStatement() (localctx IExecCicsStatementContext) {
	localctx = NewExecCicsStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, Cobol85PreprocessorParserRULE_execCicsStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(447)
		p.Match(Cobol85PreprocessorParserEXEC)
	}
	{
		p.SetState(448)
		p.Match(Cobol85PreprocessorParserCICS)
	}
	{
		p.SetState(449)
		p.CharData()
	}
	{
		p.SetState(450)
		p.Match(Cobol85PreprocessorParserEND_EXEC)
	}
	p.SetState(452)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(451)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExecSqlStatementContext() *ExecSqlStatementContext {
	var p = new(ExecSqlStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_execSqlStatement
	return p
}

func (*ExecSqlStatementContext) IsExecSqlStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_execSqlStatement

	return p
}

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

func (s *ExecSqlStatementContext) EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXEC, 0)
}

func (s *ExecSqlStatementContext) SQL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQL, 0)
}

func (s *ExecSqlStatementContext) CharDataSql() ICharDataSqlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataSqlContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataSqlContext)
}

func (s *ExecSqlStatementContext) END_EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEND_EXEC, 0)
}

func (s *ExecSqlStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *ExecSqlStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterExecSqlStatement(s)
	}
}

func (s *ExecSqlStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitExecSqlStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) ExecSqlStatement() (localctx IExecSqlStatementContext) {
	localctx = NewExecSqlStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, Cobol85PreprocessorParserRULE_execSqlStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(454)
		p.Match(Cobol85PreprocessorParserEXEC)
	}
	{
		p.SetState(455)
		p.Match(Cobol85PreprocessorParserSQL)
	}
	{
		p.SetState(456)
		p.CharDataSql()
	}
	{
		p.SetState(457)
		p.Match(Cobol85PreprocessorParserEND_EXEC)
	}
	p.SetState(459)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(458)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExecSqlImsStatementContext() *ExecSqlImsStatementContext {
	var p = new(ExecSqlImsStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_execSqlImsStatement
	return p
}

func (*ExecSqlImsStatementContext) IsExecSqlImsStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_execSqlImsStatement

	return p
}

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

func (s *ExecSqlImsStatementContext) EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXEC, 0)
}

func (s *ExecSqlImsStatementContext) SQLIMS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQLIMS, 0)
}

func (s *ExecSqlImsStatementContext) CharData() ICharDataContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataContext)
}

func (s *ExecSqlImsStatementContext) END_EXEC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEND_EXEC, 0)
}

func (s *ExecSqlImsStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *ExecSqlImsStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterExecSqlImsStatement(s)
	}
}

func (s *ExecSqlImsStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitExecSqlImsStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) ExecSqlImsStatement() (localctx IExecSqlImsStatementContext) {
	localctx = NewExecSqlImsStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, Cobol85PreprocessorParserRULE_execSqlImsStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(461)
		p.Match(Cobol85PreprocessorParserEXEC)
	}
	{
		p.SetState(462)
		p.Match(Cobol85PreprocessorParserSQLIMS)
	}
	{
		p.SetState(463)
		p.CharData()
	}
	{
		p.SetState(464)
		p.Match(Cobol85PreprocessorParserEND_EXEC)
	}
	p.SetState(466)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(465)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCopyStatementContext() *CopyStatementContext {
	var p = new(CopyStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_copyStatement
	return p
}

func (*CopyStatementContext) IsCopyStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_copyStatement

	return p
}

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

func (s *CopyStatementContext) COPY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOPY, 0)
}

func (s *CopyStatementContext) CopySource() ICopySourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICopySourceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICopySourceContext)
}

func (s *CopyStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

func (s *CopyStatementContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

func (s *CopyStatementContext) AllDirectoryPhrase() []IDirectoryPhraseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDirectoryPhraseContext)(nil)).Elem())
	var tst = make([]IDirectoryPhraseContext, len(ts))

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

	return tst
}

func (s *CopyStatementContext) DirectoryPhrase(i int) IDirectoryPhraseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectoryPhraseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDirectoryPhraseContext)
}

func (s *CopyStatementContext) AllFamilyPhrase() []IFamilyPhraseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFamilyPhraseContext)(nil)).Elem())
	var tst = make([]IFamilyPhraseContext, len(ts))

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

	return tst
}

func (s *CopyStatementContext) FamilyPhrase(i int) IFamilyPhraseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFamilyPhraseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFamilyPhraseContext)
}

func (s *CopyStatementContext) AllReplacingPhrase() []IReplacingPhraseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplacingPhraseContext)(nil)).Elem())
	var tst = make([]IReplacingPhraseContext, len(ts))

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

	return tst
}

func (s *CopyStatementContext) ReplacingPhrase(i int) IReplacingPhraseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplacingPhraseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplacingPhraseContext)
}

func (s *CopyStatementContext) AllSUPPRESS() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserSUPPRESS)
}

func (s *CopyStatementContext) SUPPRESS(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSUPPRESS, i)
}

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

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

func (s *CopyStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCopyStatement(s)
	}
}

func (s *CopyStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCopyStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) CopyStatement() (localctx ICopyStatementContext) {
	localctx = NewCopyStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, Cobol85PreprocessorParserRULE_copyStatement)
	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(468)
		p.Match(Cobol85PreprocessorParserCOPY)
	}
	{
		p.SetState(469)
		p.CopySource()
	}
	p.SetState(484)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 38, p.GetParserRuleContext())

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

			for _la == Cobol85PreprocessorParserNEWLINE {
				{
					p.SetState(470)
					p.Match(Cobol85PreprocessorParserNEWLINE)
				}

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

			switch p.GetTokenStream().LA(1) {
			case Cobol85PreprocessorParserIN, Cobol85PreprocessorParserOF:
				{
					p.SetState(476)
					p.DirectoryPhrase()
				}

			case Cobol85PreprocessorParserON:
				{
					p.SetState(477)
					p.FamilyPhrase()
				}

			case Cobol85PreprocessorParserREPLACING:
				{
					p.SetState(478)
					p.ReplacingPhrase()
				}

			case Cobol85PreprocessorParserSUPPRESS:
				{
					p.SetState(479)
					p.Match(Cobol85PreprocessorParserSUPPRESS)
				}

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

		}
		p.SetState(486)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 38, p.GetParserRuleContext())
	}
	p.SetState(490)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(487)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

		p.SetState(492)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(493)
		p.Match(Cobol85PreprocessorParserDOT)
	}

	return localctx
}

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

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

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

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

func NewEmptyCopySourceContext() *CopySourceContext {
	var p = new(CopySourceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_copySource
	return p
}

func (*CopySourceContext) IsCopySourceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_copySource

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *CopySourceContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *CopySourceContext) Filename() IFilenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilenameContext)
}

func (s *CopySourceContext) CopyLibrary() ICopyLibraryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICopyLibraryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICopyLibraryContext)
}

func (s *CopySourceContext) OF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOF, 0)
}

func (s *CopySourceContext) IN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserIN, 0)
}

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

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

func (s *CopySourceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCopySource(s)
	}
}

func (s *CopySourceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCopySource(s)
	}
}

func (p *Cobol85PreprocessorParser) CopySource() (localctx ICopySourceContext) {
	localctx = NewCopySourceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, Cobol85PreprocessorParserRULE_copySource)
	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(498)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
		{
			p.SetState(495)
			p.Literal()
		}

	case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserIDENTIFIER:
		{
			p.SetState(496)
			p.CobolWord()
		}

	case Cobol85PreprocessorParserFILENAME:
		{
			p.SetState(497)
			p.Filename()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(500)
			_la = p.GetTokenStream().LA(1)

			if !(_la == Cobol85PreprocessorParserIN || _la == Cobol85PreprocessorParserOF) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(501)
			p.CopyLibrary()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCopyLibraryContext() *CopyLibraryContext {
	var p = new(CopyLibraryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_copyLibrary
	return p
}

func (*CopyLibraryContext) IsCopyLibraryContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_copyLibrary

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *CopyLibraryContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

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

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

func (s *CopyLibraryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCopyLibrary(s)
	}
}

func (s *CopyLibraryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCopyLibrary(s)
	}
}

func (p *Cobol85PreprocessorParser) CopyLibrary() (localctx ICopyLibraryContext) {
	localctx = NewCopyLibraryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, Cobol85PreprocessorParserRULE_copyLibrary)

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

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

	switch p.GetTokenStream().LA(1) {
	case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(504)
			p.Literal()
		}

	case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(505)
			p.CobolWord()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyReplacingPhraseContext() *ReplacingPhraseContext {
	var p = new(ReplacingPhraseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replacingPhrase
	return p
}

func (*ReplacingPhraseContext) IsReplacingPhraseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replacingPhrase

	return p
}

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

func (s *ReplacingPhraseContext) REPLACING() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserREPLACING, 0)
}

func (s *ReplacingPhraseContext) AllReplaceClause() []IReplaceClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplaceClauseContext)(nil)).Elem())
	var tst = make([]IReplaceClauseContext, len(ts))

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

	return tst
}

func (s *ReplacingPhraseContext) ReplaceClause(i int) IReplaceClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplaceClauseContext)
}

func (s *ReplacingPhraseContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *ReplacingPhraseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplacingPhrase(s)
	}
}

func (s *ReplacingPhraseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplacingPhrase(s)
	}
}

func (p *Cobol85PreprocessorParser) ReplacingPhrase() (localctx IReplacingPhraseContext) {
	localctx = NewReplacingPhraseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, Cobol85PreprocessorParserRULE_replacingPhrase)
	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(508)
		p.Match(Cobol85PreprocessorParserREPLACING)
	}
	p.SetState(512)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(509)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

		p.SetState(514)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(515)
		p.ReplaceClause()
	}
	p.SetState(524)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext())

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

			for ok := true; ok; ok = _la == Cobol85PreprocessorParserNEWLINE {
				{
					p.SetState(516)
					p.Match(Cobol85PreprocessorParserNEWLINE)
				}

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

		}
		p.SetState(526)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyReplaceAreaContext() *ReplaceAreaContext {
	var p = new(ReplaceAreaContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceArea
	return p
}

func (*ReplaceAreaContext) IsReplaceAreaContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceArea

	return p
}

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

func (s *ReplaceAreaContext) ReplaceByStatement() IReplaceByStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceByStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplaceByStatementContext)
}

func (s *ReplaceAreaContext) AllCopyStatement() []ICopyStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICopyStatementContext)(nil)).Elem())
	var tst = make([]ICopyStatementContext, len(ts))

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

	return tst
}

func (s *ReplaceAreaContext) CopyStatement(i int) ICopyStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICopyStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICopyStatementContext)
}

func (s *ReplaceAreaContext) AllCharData() []ICharDataContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICharDataContext)(nil)).Elem())
	var tst = make([]ICharDataContext, len(ts))

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

	return tst
}

func (s *ReplaceAreaContext) CharData(i int) ICharDataContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICharDataContext)
}

func (s *ReplaceAreaContext) ReplaceOffStatement() IReplaceOffStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceOffStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplaceOffStatementContext)
}

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

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

func (s *ReplaceAreaContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplaceArea(s)
	}
}

func (s *ReplaceAreaContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplaceArea(s)
	}
}

func (p *Cobol85PreprocessorParser) ReplaceArea() (localctx IReplaceAreaContext) {
	localctx = NewReplaceAreaContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, Cobol85PreprocessorParserRULE_replaceArea)

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

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

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

			switch p.GetTokenStream().LA(1) {
			case Cobol85PreprocessorParserCOPY:
				{
					p.SetState(528)
					p.CopyStatement()
				}

			case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLPARENCHAR, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserRPARENCHAR, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserDOT, Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL, Cobol85PreprocessorParserIDENTIFIER, Cobol85PreprocessorParserFILENAME, Cobol85PreprocessorParserNEWLINE, Cobol85PreprocessorParserTEXT:
				{
					p.SetState(529)
					p.CharData()
				}

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 48, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(535)
			p.ReplaceOffStatement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyReplaceByStatementContext() *ReplaceByStatementContext {
	var p = new(ReplaceByStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceByStatement
	return p
}

func (*ReplaceByStatementContext) IsReplaceByStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceByStatement

	return p
}

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

func (s *ReplaceByStatementContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserREPLACE, 0)
}

func (s *ReplaceByStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

func (s *ReplaceByStatementContext) AllReplaceClause() []IReplaceClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplaceClauseContext)(nil)).Elem())
	var tst = make([]IReplaceClauseContext, len(ts))

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

	return tst
}

func (s *ReplaceByStatementContext) ReplaceClause(i int) IReplaceClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplaceClauseContext)
}

func (s *ReplaceByStatementContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *ReplaceByStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplaceByStatement(s)
	}
}

func (s *ReplaceByStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplaceByStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) ReplaceByStatement() (localctx IReplaceByStatementContext) {
	localctx = NewReplaceByStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, Cobol85PreprocessorParserRULE_replaceByStatement)
	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(538)
		p.Match(Cobol85PreprocessorParserREPLACE)
	}
	p.SetState(546)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			p.SetState(542)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == Cobol85PreprocessorParserNEWLINE {
				{
					p.SetState(539)
					p.Match(Cobol85PreprocessorParserNEWLINE)
				}

				p.SetState(544)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(545)
				p.ReplaceClause()
			}

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

		p.SetState(548)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext())
	}
	{
		p.SetState(550)
		p.Match(Cobol85PreprocessorParserDOT)
	}

	return localctx
}

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

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

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

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

func NewEmptyReplaceOffStatementContext() *ReplaceOffStatementContext {
	var p = new(ReplaceOffStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceOffStatement
	return p
}

func (*ReplaceOffStatementContext) IsReplaceOffStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceOffStatement

	return p
}

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

func (s *ReplaceOffStatementContext) REPLACE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserREPLACE, 0)
}

func (s *ReplaceOffStatementContext) OFF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOFF, 0)
}

func (s *ReplaceOffStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *ReplaceOffStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplaceOffStatement(s)
	}
}

func (s *ReplaceOffStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplaceOffStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) ReplaceOffStatement() (localctx IReplaceOffStatementContext) {
	localctx = NewReplaceOffStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, Cobol85PreprocessorParserRULE_replaceOffStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(552)
		p.Match(Cobol85PreprocessorParserREPLACE)
	}
	{
		p.SetState(553)
		p.Match(Cobol85PreprocessorParserOFF)
	}
	{
		p.SetState(554)
		p.Match(Cobol85PreprocessorParserDOT)
	}

	return localctx
}

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

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

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

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

func NewEmptyReplaceClauseContext() *ReplaceClauseContext {
	var p = new(ReplaceClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceClause
	return p
}

func (*ReplaceClauseContext) IsReplaceClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceClause

	return p
}

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

func (s *ReplaceClauseContext) Replaceable() IReplaceableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplaceableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplaceableContext)
}

func (s *ReplaceClauseContext) BY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBY, 0)
}

func (s *ReplaceClauseContext) Replacement() IReplacementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplacementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplacementContext)
}

func (s *ReplaceClauseContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

func (s *ReplaceClauseContext) DirectoryPhrase() IDirectoryPhraseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectoryPhraseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDirectoryPhraseContext)
}

func (s *ReplaceClauseContext) FamilyPhrase() IFamilyPhraseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFamilyPhraseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFamilyPhraseContext)
}

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

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

func (s *ReplaceClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplaceClause(s)
	}
}

func (s *ReplaceClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplaceClause(s)
	}
}

func (p *Cobol85PreprocessorParser) ReplaceClause() (localctx IReplaceClauseContext) {
	localctx = NewReplaceClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, Cobol85PreprocessorParserRULE_replaceClause)
	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(556)
		p.Replaceable()
	}
	p.SetState(560)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(557)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

		p.SetState(562)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(563)
		p.Match(Cobol85PreprocessorParserBY)
	}
	p.SetState(567)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(564)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

		p.SetState(569)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(570)
		p.Replacement()
	}
	p.SetState(578)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 54, p.GetParserRuleContext()) == 1 {
		p.SetState(574)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Cobol85PreprocessorParserNEWLINE {
			{
				p.SetState(571)
				p.Match(Cobol85PreprocessorParserNEWLINE)
			}

			p.SetState(576)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(577)
			p.DirectoryPhrase()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext()) == 1 {
		p.SetState(583)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Cobol85PreprocessorParserNEWLINE {
			{
				p.SetState(580)
				p.Match(Cobol85PreprocessorParserNEWLINE)
			}

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

	}

	return localctx
}

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

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

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

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

func NewEmptyDirectoryPhraseContext() *DirectoryPhraseContext {
	var p = new(DirectoryPhraseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_directoryPhrase
	return p
}

func (*DirectoryPhraseContext) IsDirectoryPhraseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_directoryPhrase

	return p
}

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

func (s *DirectoryPhraseContext) OF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOF, 0)
}

func (s *DirectoryPhraseContext) IN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserIN, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *DirectoryPhraseContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *DirectoryPhraseContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *DirectoryPhraseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterDirectoryPhrase(s)
	}
}

func (s *DirectoryPhraseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitDirectoryPhrase(s)
	}
}

func (p *Cobol85PreprocessorParser) DirectoryPhrase() (localctx IDirectoryPhraseContext) {
	localctx = NewDirectoryPhraseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, Cobol85PreprocessorParserRULE_directoryPhrase)
	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(589)
		_la = p.GetTokenStream().LA(1)

		if !(_la == Cobol85PreprocessorParserIN || _la == Cobol85PreprocessorParserOF) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(593)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(590)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

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

	switch p.GetTokenStream().LA(1) {
	case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
		{
			p.SetState(596)
			p.Literal()
		}

	case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserIDENTIFIER:
		{
			p.SetState(597)
			p.CobolWord()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFamilyPhraseContext() *FamilyPhraseContext {
	var p = new(FamilyPhraseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_familyPhrase
	return p
}

func (*FamilyPhraseContext) IsFamilyPhraseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_familyPhrase

	return p
}

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

func (s *FamilyPhraseContext) ON() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserON, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *FamilyPhraseContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *FamilyPhraseContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *FamilyPhraseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterFamilyPhrase(s)
	}
}

func (s *FamilyPhraseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitFamilyPhrase(s)
	}
}

func (p *Cobol85PreprocessorParser) FamilyPhrase() (localctx IFamilyPhraseContext) {
	localctx = NewFamilyPhraseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, Cobol85PreprocessorParserRULE_familyPhrase)
	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(600)
		p.Match(Cobol85PreprocessorParserON)
	}
	p.SetState(604)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Cobol85PreprocessorParserNEWLINE {
		{
			p.SetState(601)
			p.Match(Cobol85PreprocessorParserNEWLINE)
		}

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

	switch p.GetTokenStream().LA(1) {
	case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
		{
			p.SetState(607)
			p.Literal()
		}

	case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserIDENTIFIER:
		{
			p.SetState(608)
			p.CobolWord()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyReplaceableContext() *ReplaceableContext {
	var p = new(ReplaceableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceable
	return p
}

func (*ReplaceableContext) IsReplaceableContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replaceable

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *ReplaceableContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *ReplaceableContext) PseudoText() IPseudoTextContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPseudoTextContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPseudoTextContext)
}

func (s *ReplaceableContext) CharDataLine() ICharDataLineContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataLineContext)
}

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

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

func (s *ReplaceableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplaceable(s)
	}
}

func (s *ReplaceableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplaceable(s)
	}
}

func (p *Cobol85PreprocessorParser) Replaceable() (localctx IReplaceableContext) {
	localctx = NewReplaceableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, Cobol85PreprocessorParserRULE_replaceable)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(612)
			p.CobolWord()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(613)
			p.PseudoText()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(614)
			p.CharDataLine()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyReplacementContext() *ReplacementContext {
	var p = new(ReplacementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_replacement
	return p
}

func (*ReplacementContext) IsReplacementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_replacement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *ReplacementContext) CobolWord() ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

func (s *ReplacementContext) PseudoText() IPseudoTextContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPseudoTextContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPseudoTextContext)
}

func (s *ReplacementContext) CharDataLine() ICharDataLineContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataLineContext)
}

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

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

func (s *ReplacementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterReplacement(s)
	}
}

func (s *ReplacementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitReplacement(s)
	}
}

func (p *Cobol85PreprocessorParser) Replacement() (localctx IReplacementContext) {
	localctx = NewReplacementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, Cobol85PreprocessorParserRULE_replacement)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(618)
			p.CobolWord()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(619)
			p.PseudoText()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(620)
			p.CharDataLine()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEjectStatementContext() *EjectStatementContext {
	var p = new(EjectStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_ejectStatement
	return p
}

func (*EjectStatementContext) IsEjectStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_ejectStatement

	return p
}

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

func (s *EjectStatementContext) EJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEJECT, 0)
}

func (s *EjectStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *EjectStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterEjectStatement(s)
	}
}

func (s *EjectStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitEjectStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) EjectStatement() (localctx IEjectStatementContext) {
	localctx = NewEjectStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, Cobol85PreprocessorParserRULE_ejectStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(623)
		p.Match(Cobol85PreprocessorParserEJECT)
	}
	p.SetState(625)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(624)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySkipStatementContext() *SkipStatementContext {
	var p = new(SkipStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_skipStatement
	return p
}

func (*SkipStatementContext) IsSkipStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_skipStatement

	return p
}

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

func (s *SkipStatementContext) SKIP1() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSKIP1, 0)
}

func (s *SkipStatementContext) SKIP2() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSKIP2, 0)
}

func (s *SkipStatementContext) SKIP3() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSKIP3, 0)
}

func (s *SkipStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *SkipStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterSkipStatement(s)
	}
}

func (s *SkipStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitSkipStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) SkipStatement() (localctx ISkipStatementContext) {
	localctx = NewSkipStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, Cobol85PreprocessorParserRULE_skipStatement)
	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(627)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-238)&-(0x1f+1)) == 0 && ((1<<uint((_la-238)))&((1<<(Cobol85PreprocessorParserSKIP1-238))|(1<<(Cobol85PreprocessorParserSKIP2-238))|(1<<(Cobol85PreprocessorParserSKIP3-238)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(629)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(628)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTitleStatementContext() *TitleStatementContext {
	var p = new(TitleStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_titleStatement
	return p
}

func (*TitleStatementContext) IsTitleStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_titleStatement

	return p
}

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

func (s *TitleStatementContext) TITLE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTITLE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *TitleStatementContext) DOT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOT, 0)
}

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

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

func (s *TitleStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterTitleStatement(s)
	}
}

func (s *TitleStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitTitleStatement(s)
	}
}

func (p *Cobol85PreprocessorParser) TitleStatement() (localctx ITitleStatementContext) {
	localctx = NewTitleStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, Cobol85PreprocessorParserRULE_titleStatement)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(631)
		p.Match(Cobol85PreprocessorParserTITLE)
	}
	{
		p.SetState(632)
		p.Literal()
	}
	p.SetState(634)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 65, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(633)
			p.Match(Cobol85PreprocessorParserDOT)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyPseudoTextContext() *PseudoTextContext {
	var p = new(PseudoTextContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_pseudoText
	return p
}

func (*PseudoTextContext) IsPseudoTextContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_pseudoText

	return p
}

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

func (s *PseudoTextContext) AllDOUBLEEQUALCHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserDOUBLEEQUALCHAR)
}

func (s *PseudoTextContext) DOUBLEEQUALCHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDOUBLEEQUALCHAR, i)
}

func (s *PseudoTextContext) CharData() ICharDataContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataContext)
}

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

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

func (s *PseudoTextContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterPseudoText(s)
	}
}

func (s *PseudoTextContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitPseudoText(s)
	}
}

func (p *Cobol85PreprocessorParser) PseudoText() (localctx IPseudoTextContext) {
	localctx = NewPseudoTextContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, Cobol85PreprocessorParserRULE_pseudoText)
	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(636)
		p.Match(Cobol85PreprocessorParserDOUBLEEQUALCHAR)
	}
	p.SetState(638)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Cobol85PreprocessorParserADATA)|(1<<Cobol85PreprocessorParserADV)|(1<<Cobol85PreprocessorParserALIAS)|(1<<Cobol85PreprocessorParserANSI)|(1<<Cobol85PreprocessorParserANY)|(1<<Cobol85PreprocessorParserAPOST)|(1<<Cobol85PreprocessorParserAR)|(1<<Cobol85PreprocessorParserARITH)|(1<<Cobol85PreprocessorParserAUTO)|(1<<Cobol85PreprocessorParserAWO)|(1<<Cobol85PreprocessorParserBIN)|(1<<Cobol85PreprocessorParserBLOCK0)|(1<<Cobol85PreprocessorParserBUF)|(1<<Cobol85PreprocessorParserBUFSIZE)|(1<<Cobol85PreprocessorParserBY)|(1<<Cobol85PreprocessorParserCBL)|(1<<Cobol85PreprocessorParserCBLCARD)|(1<<Cobol85PreprocessorParserCO)|(1<<Cobol85PreprocessorParserCOBOL2)|(1<<Cobol85PreprocessorParserCOBOL3)|(1<<Cobol85PreprocessorParserCODEPAGE)|(1<<Cobol85PreprocessorParserCOMPAT)|(1<<Cobol85PreprocessorParserCOMPILE)|(1<<Cobol85PreprocessorParserCP)|(1<<Cobol85PreprocessorParserCPP)|(1<<Cobol85PreprocessorParserCPSM)|(1<<Cobol85PreprocessorParserCS)|(1<<Cobol85PreprocessorParserCURR)|(1<<Cobol85PreprocessorParserCURRENCY))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(Cobol85PreprocessorParserDATA-32))|(1<<(Cobol85PreprocessorParserDATEPROC-32))|(1<<(Cobol85PreprocessorParserDBCS-32))|(1<<(Cobol85PreprocessorParserDD-32))|(1<<(Cobol85PreprocessorParserDEBUG-32))|(1<<(Cobol85PreprocessorParserDECK-32))|(1<<(Cobol85PreprocessorParserDIAGTRUNC-32))|(1<<(Cobol85PreprocessorParserDLI-32))|(1<<(Cobol85PreprocessorParserDLL-32))|(1<<(Cobol85PreprocessorParserDP-32))|(1<<(Cobol85PreprocessorParserDTR-32))|(1<<(Cobol85PreprocessorParserDU-32))|(1<<(Cobol85PreprocessorParserDUMP-32))|(1<<(Cobol85PreprocessorParserDYN-32))|(1<<(Cobol85PreprocessorParserDYNAM-32))|(1<<(Cobol85PreprocessorParserEDF-32))|(1<<(Cobol85PreprocessorParserEJECT-32))|(1<<(Cobol85PreprocessorParserEJPD-32))|(1<<(Cobol85PreprocessorParserEN-32))|(1<<(Cobol85PreprocessorParserENGLISH-32))|(1<<(Cobol85PreprocessorParserEPILOG-32))|(1<<(Cobol85PreprocessorParserEXCI-32))|(1<<(Cobol85PreprocessorParserEXIT-32))|(1<<(Cobol85PreprocessorParserEXP-32))|(1<<(Cobol85PreprocessorParserEXPORTALL-32))|(1<<(Cobol85PreprocessorParserEXTEND-32))|(1<<(Cobol85PreprocessorParserFASTSRT-32))|(1<<(Cobol85PreprocessorParserFLAG-32))|(1<<(Cobol85PreprocessorParserFLAGSTD-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(Cobol85PreprocessorParserFSRT-64))|(1<<(Cobol85PreprocessorParserFULL-64))|(1<<(Cobol85PreprocessorParserGDS-64))|(1<<(Cobol85PreprocessorParserGRAPHIC-64))|(1<<(Cobol85PreprocessorParserHOOK-64))|(1<<(Cobol85PreprocessorParserIN-64))|(1<<(Cobol85PreprocessorParserINTDATE-64))|(1<<(Cobol85PreprocessorParserJA-64))|(1<<(Cobol85PreprocessorParserJP-64))|(1<<(Cobol85PreprocessorParserKA-64))|(1<<(Cobol85PreprocessorParserLANG-64))|(1<<(Cobol85PreprocessorParserLANGUAGE-64))|(1<<(Cobol85PreprocessorParserLC-64))|(1<<(Cobol85PreprocessorParserLENGTH-64))|(1<<(Cobol85PreprocessorParserLIB-64))|(1<<(Cobol85PreprocessorParserLILIAN-64))|(1<<(Cobol85PreprocessorParserLIN-64))|(1<<(Cobol85PreprocessorParserLINECOUNT-64))|(1<<(Cobol85PreprocessorParserLINKAGE-64))|(1<<(Cobol85PreprocessorParserLIST-64))|(1<<(Cobol85PreprocessorParserLM-64))|(1<<(Cobol85PreprocessorParserLONGMIXED-64))|(1<<(Cobol85PreprocessorParserLONGUPPER-64))|(1<<(Cobol85PreprocessorParserLPARENCHAR-64))|(1<<(Cobol85PreprocessorParserLU-64))|(1<<(Cobol85PreprocessorParserMAP-64))|(1<<(Cobol85PreprocessorParserMARGINS-64))|(1<<(Cobol85PreprocessorParserMAX-64))|(1<<(Cobol85PreprocessorParserMD-64))|(1<<(Cobol85PreprocessorParserMDECK-64))|(1<<(Cobol85PreprocessorParserMIG-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(Cobol85PreprocessorParserMIXED-96))|(1<<(Cobol85PreprocessorParserNAME-96))|(1<<(Cobol85PreprocessorParserNAT-96))|(1<<(Cobol85PreprocessorParserNATIONAL-96))|(1<<(Cobol85PreprocessorParserNATLANG-96))|(1<<(Cobol85PreprocessorParserNN-96))|(1<<(Cobol85PreprocessorParserNO-96))|(1<<(Cobol85PreprocessorParserNOADATA-96))|(1<<(Cobol85PreprocessorParserNOADV-96))|(1<<(Cobol85PreprocessorParserNOALIAS-96))|(1<<(Cobol85PreprocessorParserNOAWO-96))|(1<<(Cobol85PreprocessorParserNOBLOCK0-96))|(1<<(Cobol85PreprocessorParserNOC-96))|(1<<(Cobol85PreprocessorParserNOCBLCARD-96))|(1<<(Cobol85PreprocessorParserNOCICS-96))|(1<<(Cobol85PreprocessorParserNOCMPR2-96))|(1<<(Cobol85PreprocessorParserNOCOMPILE-96))|(1<<(Cobol85PreprocessorParserNOCPSM-96))|(1<<(Cobol85PreprocessorParserNOCURR-96))|(1<<(Cobol85PreprocessorParserNOCURRENCY-96))|(1<<(Cobol85PreprocessorParserNOD-96))|(1<<(Cobol85PreprocessorParserNODATEPROC-96))|(1<<(Cobol85PreprocessorParserNODBCS-96))|(1<<(Cobol85PreprocessorParserNODE-96))|(1<<(Cobol85PreprocessorParserNODEBUG-96))|(1<<(Cobol85PreprocessorParserNODECK-96))|(1<<(Cobol85PreprocessorParserNODIAGTRUNC-96))|(1<<(Cobol85PreprocessorParserNODLL-96))|(1<<(Cobol85PreprocessorParserNODU-96))|(1<<(Cobol85PreprocessorParserNODUMP-96))|(1<<(Cobol85PreprocessorParserNODP-96))|(1<<(Cobol85PreprocessorParserNODTR-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(Cobol85PreprocessorParserNODYN-128))|(1<<(Cobol85PreprocessorParserNODYNAM-128))|(1<<(Cobol85PreprocessorParserNOEDF-128))|(1<<(Cobol85PreprocessorParserNOEJPD-128))|(1<<(Cobol85PreprocessorParserNOEPILOG-128))|(1<<(Cobol85PreprocessorParserNOEXIT-128))|(1<<(Cobol85PreprocessorParserNOEXP-128))|(1<<(Cobol85PreprocessorParserNOEXPORTALL-128))|(1<<(Cobol85PreprocessorParserNOF-128))|(1<<(Cobol85PreprocessorParserNOFASTSRT-128))|(1<<(Cobol85PreprocessorParserNOFEPI-128))|(1<<(Cobol85PreprocessorParserNOFLAG-128))|(1<<(Cobol85PreprocessorParserNOFLAGMIG-128))|(1<<(Cobol85PreprocessorParserNOFLAGSTD-128))|(1<<(Cobol85PreprocessorParserNOFSRT-128))|(1<<(Cobol85PreprocessorParserNOGRAPHIC-128))|(1<<(Cobol85PreprocessorParserNOHOOK-128))|(1<<(Cobol85PreprocessorParserNOLENGTH-128))|(1<<(Cobol85PreprocessorParserNOLIB-128))|(1<<(Cobol85PreprocessorParserNOLINKAGE-128))|(1<<(Cobol85PreprocessorParserNOLIST-128))|(1<<(Cobol85PreprocessorParserNOMAP-128))|(1<<(Cobol85PreprocessorParserNOMD-128))|(1<<(Cobol85PreprocessorParserNOMDECK-128))|(1<<(Cobol85PreprocessorParserNONAME-128))|(1<<(Cobol85PreprocessorParserNONUM-128))|(1<<(Cobol85PreprocessorParserNONUMBER-128))|(1<<(Cobol85PreprocessorParserNOOBJ-128))|(1<<(Cobol85PreprocessorParserNOOBJECT-128))|(1<<(Cobol85PreprocessorParserNOOFF-128))|(1<<(Cobol85PreprocessorParserNOOFFSET-128))|(1<<(Cobol85PreprocessorParserNOOPSEQUENCE-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(Cobol85PreprocessorParserNOOPT-160))|(1<<(Cobol85PreprocessorParserNOOPTIMIZE-160))|(1<<(Cobol85PreprocessorParserNOOPTIONS-160))|(1<<(Cobol85PreprocessorParserNOP-160))|(1<<(Cobol85PreprocessorParserNOPFD-160))|(1<<(Cobol85PreprocessorParserNOPROLOG-160))|(1<<(Cobol85PreprocessorParserNORENT-160))|(1<<(Cobol85PreprocessorParserNOS-160))|(1<<(Cobol85PreprocessorParserNOSEP-160))|(1<<(Cobol85PreprocessorParserNOSEPARATE-160))|(1<<(Cobol85PreprocessorParserNOSEQ-160))|(1<<(Cobol85PreprocessorParserNOSOURCE-160))|(1<<(Cobol85PreprocessorParserNOSPIE-160))|(1<<(Cobol85PreprocessorParserNOSQL-160))|(1<<(Cobol85PreprocessorParserNOSQLC-160))|(1<<(Cobol85PreprocessorParserNOSQLCCSID-160))|(1<<(Cobol85PreprocessorParserNOSSR-160))|(1<<(Cobol85PreprocessorParserNOSSRANGE-160))|(1<<(Cobol85PreprocessorParserNOSTDTRUNC-160))|(1<<(Cobol85PreprocessorParserNOSEQUENCE-160))|(1<<(Cobol85PreprocessorParserNOTERM-160))|(1<<(Cobol85PreprocessorParserNOTERMINAL-160))|(1<<(Cobol85PreprocessorParserNOTEST-160))|(1<<(Cobol85PreprocessorParserNOTHREAD-160))|(1<<(Cobol85PreprocessorParserNOTRIG-160))|(1<<(Cobol85PreprocessorParserNOVBREF-160))|(1<<(Cobol85PreprocessorParserNOWORD-160))|(1<<(Cobol85PreprocessorParserNOX-160))|(1<<(Cobol85PreprocessorParserNOXREF-160))|(1<<(Cobol85PreprocessorParserNOZWB-160))|(1<<(Cobol85PreprocessorParserNS-160)))) != 0) || (((_la-192)&-(0x1f+1)) == 0 && ((1<<uint((_la-192)))&((1<<(Cobol85PreprocessorParserNSEQ-192))|(1<<(Cobol85PreprocessorParserNSYMBOL-192))|(1<<(Cobol85PreprocessorParserNUM-192))|(1<<(Cobol85PreprocessorParserNUMBER-192))|(1<<(Cobol85PreprocessorParserNUMPROC-192))|(1<<(Cobol85PreprocessorParserOBJ-192))|(1<<(Cobol85PreprocessorParserOBJECT-192))|(1<<(Cobol85PreprocessorParserOF-192))|(1<<(Cobol85PreprocessorParserOFF-192))|(1<<(Cobol85PreprocessorParserOFFSET-192))|(1<<(Cobol85PreprocessorParserON-192))|(1<<(Cobol85PreprocessorParserOP-192))|(1<<(Cobol85PreprocessorParserOPMARGINS-192))|(1<<(Cobol85PreprocessorParserOPSEQUENCE-192))|(1<<(Cobol85PreprocessorParserOPT-192))|(1<<(Cobol85PreprocessorParserOPTFILE-192))|(1<<(Cobol85PreprocessorParserOPTIMIZE-192))|(1<<(Cobol85PreprocessorParserOPTIONS-192))|(1<<(Cobol85PreprocessorParserOUT-192))|(1<<(Cobol85PreprocessorParserOUTDD-192))|(1<<(Cobol85PreprocessorParserPFD-192))|(1<<(Cobol85PreprocessorParserPPTDBG-192))|(1<<(Cobol85PreprocessorParserPGMN-192))|(1<<(Cobol85PreprocessorParserPGMNAME-192))|(1<<(Cobol85PreprocessorParserPROCESS-192))|(1<<(Cobol85PreprocessorParserPROLOG-192))|(1<<(Cobol85PreprocessorParserQUOTE-192))|(1<<(Cobol85PreprocessorParserRENT-192))|(1<<(Cobol85PreprocessorParserREPLACING-192))|(1<<(Cobol85PreprocessorParserRMODE-192))|(1<<(Cobol85PreprocessorParserRPARENCHAR-192)))) != 0) || (((_la-224)&-(0x1f+1)) == 0 && ((1<<uint((_la-224)))&((1<<(Cobol85PreprocessorParserSEP-224))|(1<<(Cobol85PreprocessorParserSEPARATE-224))|(1<<(Cobol85PreprocessorParserSEQ-224))|(1<<(Cobol85PreprocessorParserSEQUENCE-224))|(1<<(Cobol85PreprocessorParserSHORT-224))|(1<<(Cobol85PreprocessorParserSIZE-224))|(1<<(Cobol85PreprocessorParserSOURCE-224))|(1<<(Cobol85PreprocessorParserSP-224))|(1<<(Cobol85PreprocessorParserSPACE-224))|(1<<(Cobol85PreprocessorParserSPIE-224))|(1<<(Cobol85PreprocessorParserSQL-224))|(1<<(Cobol85PreprocessorParserSQLC-224))|(1<<(Cobol85PreprocessorParserSQLCCSID-224))|(1<<(Cobol85PreprocessorParserSS-224))|(1<<(Cobol85PreprocessorParserSSR-224))|(1<<(Cobol85PreprocessorParserSSRANGE-224))|(1<<(Cobol85PreprocessorParserSTD-224))|(1<<(Cobol85PreprocessorParserSYSEIB-224))|(1<<(Cobol85PreprocessorParserSZ-224))|(1<<(Cobol85PreprocessorParserTERM-224))|(1<<(Cobol85PreprocessorParserTERMINAL-224))|(1<<(Cobol85PreprocessorParserTEST-224))|(1<<(Cobol85PreprocessorParserTHREAD-224))|(1<<(Cobol85PreprocessorParserTITLE-224))|(1<<(Cobol85PreprocessorParserTRIG-224))|(1<<(Cobol85PreprocessorParserTRUNC-224))|(1<<(Cobol85PreprocessorParserUE-224)))) != 0) || (((_la-256)&-(0x1f+1)) == 0 && ((1<<uint((_la-256)))&((1<<(Cobol85PreprocessorParserUPPER-256))|(1<<(Cobol85PreprocessorParserVBREF-256))|(1<<(Cobol85PreprocessorParserWD-256))|(1<<(Cobol85PreprocessorParserXMLPARSE-256))|(1<<(Cobol85PreprocessorParserXMLSS-256))|(1<<(Cobol85PreprocessorParserXOPTS-256))|(1<<(Cobol85PreprocessorParserXREF-256))|(1<<(Cobol85PreprocessorParserYEARWINDOW-256))|(1<<(Cobol85PreprocessorParserYW-256))|(1<<(Cobol85PreprocessorParserZWB-256))|(1<<(Cobol85PreprocessorParserC_CHAR-256))|(1<<(Cobol85PreprocessorParserD_CHAR-256))|(1<<(Cobol85PreprocessorParserE_CHAR-256))|(1<<(Cobol85PreprocessorParserF_CHAR-256))|(1<<(Cobol85PreprocessorParserH_CHAR-256))|(1<<(Cobol85PreprocessorParserI_CHAR-256))|(1<<(Cobol85PreprocessorParserM_CHAR-256))|(1<<(Cobol85PreprocessorParserN_CHAR-256))|(1<<(Cobol85PreprocessorParserQ_CHAR-256))|(1<<(Cobol85PreprocessorParserS_CHAR-256))|(1<<(Cobol85PreprocessorParserU_CHAR-256))|(1<<(Cobol85PreprocessorParserW_CHAR-256))|(1<<(Cobol85PreprocessorParserX_CHAR-256))|(1<<(Cobol85PreprocessorParserCOMMACHAR-256))|(1<<(Cobol85PreprocessorParserDOT-256))|(1<<(Cobol85PreprocessorParserNONNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserIDENTIFIER-256)))) != 0) || (((_la-288)&-(0x1f+1)) == 0 && ((1<<uint((_la-288)))&((1<<(Cobol85PreprocessorParserFILENAME-288))|(1<<(Cobol85PreprocessorParserNEWLINE-288))|(1<<(Cobol85PreprocessorParserTEXT-288)))) != 0) {
		{
			p.SetState(637)
			p.CharData()
		}

	}
	{
		p.SetState(640)
		p.Match(Cobol85PreprocessorParserDOUBLEEQUALCHAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyCharDataContext() *CharDataContext {
	var p = new(CharDataContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_charData
	return p
}

func (*CharDataContext) IsCharDataContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_charData

	return p
}

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

func (s *CharDataContext) AllCharDataLine() []ICharDataLineContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem())
	var tst = make([]ICharDataLineContext, len(ts))

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

	return tst
}

func (s *CharDataContext) CharDataLine(i int) ICharDataLineContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICharDataLineContext)
}

func (s *CharDataContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *CharDataContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCharData(s)
	}
}

func (s *CharDataContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCharData(s)
	}
}

func (p *Cobol85PreprocessorParser) CharData() (localctx ICharDataContext) {
	localctx = NewCharDataContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, Cobol85PreprocessorParserRULE_charData)

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

	defer func() {
		if err := recover(); err != 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(644)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			p.SetState(644)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLPARENCHAR, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserRPARENCHAR, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserDOT, Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL, Cobol85PreprocessorParserIDENTIFIER, Cobol85PreprocessorParserFILENAME, Cobol85PreprocessorParserTEXT:
				{
					p.SetState(642)
					p.CharDataLine()
				}

			case Cobol85PreprocessorParserNEWLINE:
				{
					p.SetState(643)
					p.Match(Cobol85PreprocessorParserNEWLINE)
				}

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

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

		p.SetState(646)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyCharDataSqlContext() *CharDataSqlContext {
	var p = new(CharDataSqlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataSql
	return p
}

func (*CharDataSqlContext) IsCharDataSqlContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataSql

	return p
}

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

func (s *CharDataSqlContext) AllCharDataLine() []ICharDataLineContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem())
	var tst = make([]ICharDataLineContext, len(ts))

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

	return tst
}

func (s *CharDataSqlContext) CharDataLine(i int) ICharDataLineContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataLineContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICharDataLineContext)
}

func (s *CharDataSqlContext) AllCOPY() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserCOPY)
}

func (s *CharDataSqlContext) COPY(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOPY, i)
}

func (s *CharDataSqlContext) AllREPLACE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserREPLACE)
}

func (s *CharDataSqlContext) REPLACE(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserREPLACE, i)
}

func (s *CharDataSqlContext) AllNEWLINE() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserNEWLINE)
}

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

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

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

func (s *CharDataSqlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCharDataSql(s)
	}
}

func (s *CharDataSqlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCharDataSql(s)
	}
}

func (p *Cobol85PreprocessorParser) CharDataSql() (localctx ICharDataSqlContext) {
	localctx = NewCharDataSqlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, Cobol85PreprocessorParserRULE_charDataSql)
	var _la int

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

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

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

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Cobol85PreprocessorParserADATA)|(1<<Cobol85PreprocessorParserADV)|(1<<Cobol85PreprocessorParserALIAS)|(1<<Cobol85PreprocessorParserANSI)|(1<<Cobol85PreprocessorParserANY)|(1<<Cobol85PreprocessorParserAPOST)|(1<<Cobol85PreprocessorParserAR)|(1<<Cobol85PreprocessorParserARITH)|(1<<Cobol85PreprocessorParserAUTO)|(1<<Cobol85PreprocessorParserAWO)|(1<<Cobol85PreprocessorParserBIN)|(1<<Cobol85PreprocessorParserBLOCK0)|(1<<Cobol85PreprocessorParserBUF)|(1<<Cobol85PreprocessorParserBUFSIZE)|(1<<Cobol85PreprocessorParserBY)|(1<<Cobol85PreprocessorParserCBL)|(1<<Cobol85PreprocessorParserCBLCARD)|(1<<Cobol85PreprocessorParserCO)|(1<<Cobol85PreprocessorParserCOBOL2)|(1<<Cobol85PreprocessorParserCOBOL3)|(1<<Cobol85PreprocessorParserCODEPAGE)|(1<<Cobol85PreprocessorParserCOMPAT)|(1<<Cobol85PreprocessorParserCOMPILE)|(1<<Cobol85PreprocessorParserCOPY)|(1<<Cobol85PreprocessorParserCP)|(1<<Cobol85PreprocessorParserCPP)|(1<<Cobol85PreprocessorParserCPSM)|(1<<Cobol85PreprocessorParserCS)|(1<<Cobol85PreprocessorParserCURR)|(1<<Cobol85PreprocessorParserCURRENCY))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(Cobol85PreprocessorParserDATA-32))|(1<<(Cobol85PreprocessorParserDATEPROC-32))|(1<<(Cobol85PreprocessorParserDBCS-32))|(1<<(Cobol85PreprocessorParserDD-32))|(1<<(Cobol85PreprocessorParserDEBUG-32))|(1<<(Cobol85PreprocessorParserDECK-32))|(1<<(Cobol85PreprocessorParserDIAGTRUNC-32))|(1<<(Cobol85PreprocessorParserDLI-32))|(1<<(Cobol85PreprocessorParserDLL-32))|(1<<(Cobol85PreprocessorParserDP-32))|(1<<(Cobol85PreprocessorParserDTR-32))|(1<<(Cobol85PreprocessorParserDU-32))|(1<<(Cobol85PreprocessorParserDUMP-32))|(1<<(Cobol85PreprocessorParserDYN-32))|(1<<(Cobol85PreprocessorParserDYNAM-32))|(1<<(Cobol85PreprocessorParserEDF-32))|(1<<(Cobol85PreprocessorParserEJECT-32))|(1<<(Cobol85PreprocessorParserEJPD-32))|(1<<(Cobol85PreprocessorParserEN-32))|(1<<(Cobol85PreprocessorParserENGLISH-32))|(1<<(Cobol85PreprocessorParserEPILOG-32))|(1<<(Cobol85PreprocessorParserEXCI-32))|(1<<(Cobol85PreprocessorParserEXIT-32))|(1<<(Cobol85PreprocessorParserEXP-32))|(1<<(Cobol85PreprocessorParserEXPORTALL-32))|(1<<(Cobol85PreprocessorParserEXTEND-32))|(1<<(Cobol85PreprocessorParserFASTSRT-32))|(1<<(Cobol85PreprocessorParserFLAG-32))|(1<<(Cobol85PreprocessorParserFLAGSTD-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(Cobol85PreprocessorParserFSRT-64))|(1<<(Cobol85PreprocessorParserFULL-64))|(1<<(Cobol85PreprocessorParserGDS-64))|(1<<(Cobol85PreprocessorParserGRAPHIC-64))|(1<<(Cobol85PreprocessorParserHOOK-64))|(1<<(Cobol85PreprocessorParserIN-64))|(1<<(Cobol85PreprocessorParserINTDATE-64))|(1<<(Cobol85PreprocessorParserJA-64))|(1<<(Cobol85PreprocessorParserJP-64))|(1<<(Cobol85PreprocessorParserKA-64))|(1<<(Cobol85PreprocessorParserLANG-64))|(1<<(Cobol85PreprocessorParserLANGUAGE-64))|(1<<(Cobol85PreprocessorParserLC-64))|(1<<(Cobol85PreprocessorParserLENGTH-64))|(1<<(Cobol85PreprocessorParserLIB-64))|(1<<(Cobol85PreprocessorParserLILIAN-64))|(1<<(Cobol85PreprocessorParserLIN-64))|(1<<(Cobol85PreprocessorParserLINECOUNT-64))|(1<<(Cobol85PreprocessorParserLINKAGE-64))|(1<<(Cobol85PreprocessorParserLIST-64))|(1<<(Cobol85PreprocessorParserLM-64))|(1<<(Cobol85PreprocessorParserLONGMIXED-64))|(1<<(Cobol85PreprocessorParserLONGUPPER-64))|(1<<(Cobol85PreprocessorParserLPARENCHAR-64))|(1<<(Cobol85PreprocessorParserLU-64))|(1<<(Cobol85PreprocessorParserMAP-64))|(1<<(Cobol85PreprocessorParserMARGINS-64))|(1<<(Cobol85PreprocessorParserMAX-64))|(1<<(Cobol85PreprocessorParserMD-64))|(1<<(Cobol85PreprocessorParserMDECK-64))|(1<<(Cobol85PreprocessorParserMIG-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(Cobol85PreprocessorParserMIXED-96))|(1<<(Cobol85PreprocessorParserNAME-96))|(1<<(Cobol85PreprocessorParserNAT-96))|(1<<(Cobol85PreprocessorParserNATIONAL-96))|(1<<(Cobol85PreprocessorParserNATLANG-96))|(1<<(Cobol85PreprocessorParserNN-96))|(1<<(Cobol85PreprocessorParserNO-96))|(1<<(Cobol85PreprocessorParserNOADATA-96))|(1<<(Cobol85PreprocessorParserNOADV-96))|(1<<(Cobol85PreprocessorParserNOALIAS-96))|(1<<(Cobol85PreprocessorParserNOAWO-96))|(1<<(Cobol85PreprocessorParserNOBLOCK0-96))|(1<<(Cobol85PreprocessorParserNOC-96))|(1<<(Cobol85PreprocessorParserNOCBLCARD-96))|(1<<(Cobol85PreprocessorParserNOCICS-96))|(1<<(Cobol85PreprocessorParserNOCMPR2-96))|(1<<(Cobol85PreprocessorParserNOCOMPILE-96))|(1<<(Cobol85PreprocessorParserNOCPSM-96))|(1<<(Cobol85PreprocessorParserNOCURR-96))|(1<<(Cobol85PreprocessorParserNOCURRENCY-96))|(1<<(Cobol85PreprocessorParserNOD-96))|(1<<(Cobol85PreprocessorParserNODATEPROC-96))|(1<<(Cobol85PreprocessorParserNODBCS-96))|(1<<(Cobol85PreprocessorParserNODE-96))|(1<<(Cobol85PreprocessorParserNODEBUG-96))|(1<<(Cobol85PreprocessorParserNODECK-96))|(1<<(Cobol85PreprocessorParserNODIAGTRUNC-96))|(1<<(Cobol85PreprocessorParserNODLL-96))|(1<<(Cobol85PreprocessorParserNODU-96))|(1<<(Cobol85PreprocessorParserNODUMP-96))|(1<<(Cobol85PreprocessorParserNODP-96))|(1<<(Cobol85PreprocessorParserNODTR-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(Cobol85PreprocessorParserNODYN-128))|(1<<(Cobol85PreprocessorParserNODYNAM-128))|(1<<(Cobol85PreprocessorParserNOEDF-128))|(1<<(Cobol85PreprocessorParserNOEJPD-128))|(1<<(Cobol85PreprocessorParserNOEPILOG-128))|(1<<(Cobol85PreprocessorParserNOEXIT-128))|(1<<(Cobol85PreprocessorParserNOEXP-128))|(1<<(Cobol85PreprocessorParserNOEXPORTALL-128))|(1<<(Cobol85PreprocessorParserNOF-128))|(1<<(Cobol85PreprocessorParserNOFASTSRT-128))|(1<<(Cobol85PreprocessorParserNOFEPI-128))|(1<<(Cobol85PreprocessorParserNOFLAG-128))|(1<<(Cobol85PreprocessorParserNOFLAGMIG-128))|(1<<(Cobol85PreprocessorParserNOFLAGSTD-128))|(1<<(Cobol85PreprocessorParserNOFSRT-128))|(1<<(Cobol85PreprocessorParserNOGRAPHIC-128))|(1<<(Cobol85PreprocessorParserNOHOOK-128))|(1<<(Cobol85PreprocessorParserNOLENGTH-128))|(1<<(Cobol85PreprocessorParserNOLIB-128))|(1<<(Cobol85PreprocessorParserNOLINKAGE-128))|(1<<(Cobol85PreprocessorParserNOLIST-128))|(1<<(Cobol85PreprocessorParserNOMAP-128))|(1<<(Cobol85PreprocessorParserNOMD-128))|(1<<(Cobol85PreprocessorParserNOMDECK-128))|(1<<(Cobol85PreprocessorParserNONAME-128))|(1<<(Cobol85PreprocessorParserNONUM-128))|(1<<(Cobol85PreprocessorParserNONUMBER-128))|(1<<(Cobol85PreprocessorParserNOOBJ-128))|(1<<(Cobol85PreprocessorParserNOOBJECT-128))|(1<<(Cobol85PreprocessorParserNOOFF-128))|(1<<(Cobol85PreprocessorParserNOOFFSET-128))|(1<<(Cobol85PreprocessorParserNOOPSEQUENCE-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(Cobol85PreprocessorParserNOOPT-160))|(1<<(Cobol85PreprocessorParserNOOPTIMIZE-160))|(1<<(Cobol85PreprocessorParserNOOPTIONS-160))|(1<<(Cobol85PreprocessorParserNOP-160))|(1<<(Cobol85PreprocessorParserNOPFD-160))|(1<<(Cobol85PreprocessorParserNOPROLOG-160))|(1<<(Cobol85PreprocessorParserNORENT-160))|(1<<(Cobol85PreprocessorParserNOS-160))|(1<<(Cobol85PreprocessorParserNOSEP-160))|(1<<(Cobol85PreprocessorParserNOSEPARATE-160))|(1<<(Cobol85PreprocessorParserNOSEQ-160))|(1<<(Cobol85PreprocessorParserNOSOURCE-160))|(1<<(Cobol85PreprocessorParserNOSPIE-160))|(1<<(Cobol85PreprocessorParserNOSQL-160))|(1<<(Cobol85PreprocessorParserNOSQLC-160))|(1<<(Cobol85PreprocessorParserNOSQLCCSID-160))|(1<<(Cobol85PreprocessorParserNOSSR-160))|(1<<(Cobol85PreprocessorParserNOSSRANGE-160))|(1<<(Cobol85PreprocessorParserNOSTDTRUNC-160))|(1<<(Cobol85PreprocessorParserNOSEQUENCE-160))|(1<<(Cobol85PreprocessorParserNOTERM-160))|(1<<(Cobol85PreprocessorParserNOTERMINAL-160))|(1<<(Cobol85PreprocessorParserNOTEST-160))|(1<<(Cobol85PreprocessorParserNOTHREAD-160))|(1<<(Cobol85PreprocessorParserNOTRIG-160))|(1<<(Cobol85PreprocessorParserNOVBREF-160))|(1<<(Cobol85PreprocessorParserNOWORD-160))|(1<<(Cobol85PreprocessorParserNOX-160))|(1<<(Cobol85PreprocessorParserNOXREF-160))|(1<<(Cobol85PreprocessorParserNOZWB-160))|(1<<(Cobol85PreprocessorParserNS-160)))) != 0) || (((_la-192)&-(0x1f+1)) == 0 && ((1<<uint((_la-192)))&((1<<(Cobol85PreprocessorParserNSEQ-192))|(1<<(Cobol85PreprocessorParserNSYMBOL-192))|(1<<(Cobol85PreprocessorParserNUM-192))|(1<<(Cobol85PreprocessorParserNUMBER-192))|(1<<(Cobol85PreprocessorParserNUMPROC-192))|(1<<(Cobol85PreprocessorParserOBJ-192))|(1<<(Cobol85PreprocessorParserOBJECT-192))|(1<<(Cobol85PreprocessorParserOF-192))|(1<<(Cobol85PreprocessorParserOFF-192))|(1<<(Cobol85PreprocessorParserOFFSET-192))|(1<<(Cobol85PreprocessorParserON-192))|(1<<(Cobol85PreprocessorParserOP-192))|(1<<(Cobol85PreprocessorParserOPMARGINS-192))|(1<<(Cobol85PreprocessorParserOPSEQUENCE-192))|(1<<(Cobol85PreprocessorParserOPT-192))|(1<<(Cobol85PreprocessorParserOPTFILE-192))|(1<<(Cobol85PreprocessorParserOPTIMIZE-192))|(1<<(Cobol85PreprocessorParserOPTIONS-192))|(1<<(Cobol85PreprocessorParserOUT-192))|(1<<(Cobol85PreprocessorParserOUTDD-192))|(1<<(Cobol85PreprocessorParserPFD-192))|(1<<(Cobol85PreprocessorParserPPTDBG-192))|(1<<(Cobol85PreprocessorParserPGMN-192))|(1<<(Cobol85PreprocessorParserPGMNAME-192))|(1<<(Cobol85PreprocessorParserPROCESS-192))|(1<<(Cobol85PreprocessorParserPROLOG-192))|(1<<(Cobol85PreprocessorParserQUOTE-192))|(1<<(Cobol85PreprocessorParserRENT-192))|(1<<(Cobol85PreprocessorParserREPLACE-192))|(1<<(Cobol85PreprocessorParserREPLACING-192))|(1<<(Cobol85PreprocessorParserRMODE-192))|(1<<(Cobol85PreprocessorParserRPARENCHAR-192)))) != 0) || (((_la-224)&-(0x1f+1)) == 0 && ((1<<uint((_la-224)))&((1<<(Cobol85PreprocessorParserSEP-224))|(1<<(Cobol85PreprocessorParserSEPARATE-224))|(1<<(Cobol85PreprocessorParserSEQ-224))|(1<<(Cobol85PreprocessorParserSEQUENCE-224))|(1<<(Cobol85PreprocessorParserSHORT-224))|(1<<(Cobol85PreprocessorParserSIZE-224))|(1<<(Cobol85PreprocessorParserSOURCE-224))|(1<<(Cobol85PreprocessorParserSP-224))|(1<<(Cobol85PreprocessorParserSPACE-224))|(1<<(Cobol85PreprocessorParserSPIE-224))|(1<<(Cobol85PreprocessorParserSQL-224))|(1<<(Cobol85PreprocessorParserSQLC-224))|(1<<(Cobol85PreprocessorParserSQLCCSID-224))|(1<<(Cobol85PreprocessorParserSS-224))|(1<<(Cobol85PreprocessorParserSSR-224))|(1<<(Cobol85PreprocessorParserSSRANGE-224))|(1<<(Cobol85PreprocessorParserSTD-224))|(1<<(Cobol85PreprocessorParserSYSEIB-224))|(1<<(Cobol85PreprocessorParserSZ-224))|(1<<(Cobol85PreprocessorParserTERM-224))|(1<<(Cobol85PreprocessorParserTERMINAL-224))|(1<<(Cobol85PreprocessorParserTEST-224))|(1<<(Cobol85PreprocessorParserTHREAD-224))|(1<<(Cobol85PreprocessorParserTITLE-224))|(1<<(Cobol85PreprocessorParserTRIG-224))|(1<<(Cobol85PreprocessorParserTRUNC-224))|(1<<(Cobol85PreprocessorParserUE-224)))) != 0) || (((_la-256)&-(0x1f+1)) == 0 && ((1<<uint((_la-256)))&((1<<(Cobol85PreprocessorParserUPPER-256))|(1<<(Cobol85PreprocessorParserVBREF-256))|(1<<(Cobol85PreprocessorParserWD-256))|(1<<(Cobol85PreprocessorParserXMLPARSE-256))|(1<<(Cobol85PreprocessorParserXMLSS-256))|(1<<(Cobol85PreprocessorParserXOPTS-256))|(1<<(Cobol85PreprocessorParserXREF-256))|(1<<(Cobol85PreprocessorParserYEARWINDOW-256))|(1<<(Cobol85PreprocessorParserYW-256))|(1<<(Cobol85PreprocessorParserZWB-256))|(1<<(Cobol85PreprocessorParserC_CHAR-256))|(1<<(Cobol85PreprocessorParserD_CHAR-256))|(1<<(Cobol85PreprocessorParserE_CHAR-256))|(1<<(Cobol85PreprocessorParserF_CHAR-256))|(1<<(Cobol85PreprocessorParserH_CHAR-256))|(1<<(Cobol85PreprocessorParserI_CHAR-256))|(1<<(Cobol85PreprocessorParserM_CHAR-256))|(1<<(Cobol85PreprocessorParserN_CHAR-256))|(1<<(Cobol85PreprocessorParserQ_CHAR-256))|(1<<(Cobol85PreprocessorParserS_CHAR-256))|(1<<(Cobol85PreprocessorParserU_CHAR-256))|(1<<(Cobol85PreprocessorParserW_CHAR-256))|(1<<(Cobol85PreprocessorParserX_CHAR-256))|(1<<(Cobol85PreprocessorParserCOMMACHAR-256))|(1<<(Cobol85PreprocessorParserDOT-256))|(1<<(Cobol85PreprocessorParserNONNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserNUMERICLITERAL-256))|(1<<(Cobol85PreprocessorParserIDENTIFIER-256)))) != 0) || (((_la-288)&-(0x1f+1)) == 0 && ((1<<uint((_la-288)))&((1<<(Cobol85PreprocessorParserFILENAME-288))|(1<<(Cobol85PreprocessorParserNEWLINE-288))|(1<<(Cobol85PreprocessorParserTEXT-288)))) != 0) {
		p.SetState(652)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLPARENCHAR, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserRPARENCHAR, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserDOT, Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL, Cobol85PreprocessorParserIDENTIFIER, Cobol85PreprocessorParserFILENAME, Cobol85PreprocessorParserTEXT:
			{
				p.SetState(648)
				p.CharDataLine()
			}

		case Cobol85PreprocessorParserCOPY:
			{
				p.SetState(649)
				p.Match(Cobol85PreprocessorParserCOPY)
			}

		case Cobol85PreprocessorParserREPLACE:
			{
				p.SetState(650)
				p.Match(Cobol85PreprocessorParserREPLACE)
			}

		case Cobol85PreprocessorParserNEWLINE:
			{
				p.SetState(651)
				p.Match(Cobol85PreprocessorParserNEWLINE)
			}

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

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

	return localctx
}

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

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

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

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

func NewEmptyCharDataLineContext() *CharDataLineContext {
	var p = new(CharDataLineContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataLine
	return p
}

func (*CharDataLineContext) IsCharDataLineContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataLine

	return p
}

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

func (s *CharDataLineContext) AllCobolWord() []ICobolWordContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICobolWordContext)(nil)).Elem())
	var tst = make([]ICobolWordContext, len(ts))

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

	return tst
}

func (s *CharDataLineContext) CobolWord(i int) ICobolWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICobolWordContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICobolWordContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *CharDataLineContext) AllFilename() []IFilenameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFilenameContext)(nil)).Elem())
	var tst = make([]IFilenameContext, len(ts))

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

	return tst
}

func (s *CharDataLineContext) Filename(i int) IFilenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilenameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFilenameContext)
}

func (s *CharDataLineContext) AllTEXT() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserTEXT)
}

func (s *CharDataLineContext) TEXT(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTEXT, i)
}

func (s *CharDataLineContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserDOT)
}

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

func (s *CharDataLineContext) AllLPARENCHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserLPARENCHAR)
}

func (s *CharDataLineContext) LPARENCHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLPARENCHAR, i)
}

func (s *CharDataLineContext) AllRPARENCHAR() []antlr.TerminalNode {
	return s.GetTokens(Cobol85PreprocessorParserRPARENCHAR)
}

func (s *CharDataLineContext) RPARENCHAR(i int) antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRPARENCHAR, i)
}

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

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

func (s *CharDataLineContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCharDataLine(s)
	}
}

func (s *CharDataLineContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCharDataLine(s)
	}
}

func (p *Cobol85PreprocessorParser) CharDataLine() (localctx ICharDataLineContext) {
	localctx = NewCharDataLineContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, Cobol85PreprocessorParserRULE_charDataLine)

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

	defer func() {
		if err := recover(); err != 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(663)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			p.SetState(663)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR, Cobol85PreprocessorParserIDENTIFIER:
				{
					p.SetState(656)
					p.CobolWord()
				}

			case Cobol85PreprocessorParserNONNUMERICLITERAL, Cobol85PreprocessorParserNUMERICLITERAL:
				{
					p.SetState(657)
					p.Literal()
				}

			case Cobol85PreprocessorParserFILENAME:
				{
					p.SetState(658)
					p.Filename()
				}

			case Cobol85PreprocessorParserTEXT:
				{
					p.SetState(659)
					p.Match(Cobol85PreprocessorParserTEXT)
				}

			case Cobol85PreprocessorParserDOT:
				{
					p.SetState(660)
					p.Match(Cobol85PreprocessorParserDOT)
				}

			case Cobol85PreprocessorParserLPARENCHAR:
				{
					p.SetState(661)
					p.Match(Cobol85PreprocessorParserLPARENCHAR)
				}

			case Cobol85PreprocessorParserRPARENCHAR:
				{
					p.SetState(662)
					p.Match(Cobol85PreprocessorParserRPARENCHAR)
				}

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

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

		p.SetState(665)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyCobolWordContext() *CobolWordContext {
	var p = new(CobolWordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_cobolWord
	return p
}

func (*CobolWordContext) IsCobolWordContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_cobolWord

	return p
}

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

func (s *CobolWordContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserIDENTIFIER, 0)
}

func (s *CobolWordContext) CharDataKeyword() ICharDataKeywordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICharDataKeywordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICharDataKeywordContext)
}

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

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

func (s *CobolWordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCobolWord(s)
	}
}

func (s *CobolWordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCobolWord(s)
	}
}

func (p *Cobol85PreprocessorParser) CobolWord() (localctx ICobolWordContext) {
	localctx = NewCobolWordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, Cobol85PreprocessorParserRULE_cobolWord)

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

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

	switch p.GetTokenStream().LA(1) {
	case Cobol85PreprocessorParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(667)
			p.Match(Cobol85PreprocessorParserIDENTIFIER)
		}

	case Cobol85PreprocessorParserADATA, Cobol85PreprocessorParserADV, Cobol85PreprocessorParserALIAS, Cobol85PreprocessorParserANSI, Cobol85PreprocessorParserANY, Cobol85PreprocessorParserAPOST, Cobol85PreprocessorParserAR, Cobol85PreprocessorParserARITH, Cobol85PreprocessorParserAUTO, Cobol85PreprocessorParserAWO, Cobol85PreprocessorParserBIN, Cobol85PreprocessorParserBLOCK0, Cobol85PreprocessorParserBUF, Cobol85PreprocessorParserBUFSIZE, Cobol85PreprocessorParserBY, Cobol85PreprocessorParserCBL, Cobol85PreprocessorParserCBLCARD, Cobol85PreprocessorParserCO, Cobol85PreprocessorParserCOBOL2, Cobol85PreprocessorParserCOBOL3, Cobol85PreprocessorParserCODEPAGE, Cobol85PreprocessorParserCOMPAT, Cobol85PreprocessorParserCOMPILE, Cobol85PreprocessorParserCP, Cobol85PreprocessorParserCPP, Cobol85PreprocessorParserCPSM, Cobol85PreprocessorParserCS, Cobol85PreprocessorParserCURR, Cobol85PreprocessorParserCURRENCY, Cobol85PreprocessorParserDATA, Cobol85PreprocessorParserDATEPROC, Cobol85PreprocessorParserDBCS, Cobol85PreprocessorParserDD, Cobol85PreprocessorParserDEBUG, Cobol85PreprocessorParserDECK, Cobol85PreprocessorParserDIAGTRUNC, Cobol85PreprocessorParserDLI, Cobol85PreprocessorParserDLL, Cobol85PreprocessorParserDP, Cobol85PreprocessorParserDTR, Cobol85PreprocessorParserDU, Cobol85PreprocessorParserDUMP, Cobol85PreprocessorParserDYN, Cobol85PreprocessorParserDYNAM, Cobol85PreprocessorParserEDF, Cobol85PreprocessorParserEJECT, Cobol85PreprocessorParserEJPD, Cobol85PreprocessorParserEN, Cobol85PreprocessorParserENGLISH, Cobol85PreprocessorParserEPILOG, Cobol85PreprocessorParserEXCI, Cobol85PreprocessorParserEXIT, Cobol85PreprocessorParserEXP, Cobol85PreprocessorParserEXPORTALL, Cobol85PreprocessorParserEXTEND, Cobol85PreprocessorParserFASTSRT, Cobol85PreprocessorParserFLAG, Cobol85PreprocessorParserFLAGSTD, Cobol85PreprocessorParserFSRT, Cobol85PreprocessorParserFULL, Cobol85PreprocessorParserGDS, Cobol85PreprocessorParserGRAPHIC, Cobol85PreprocessorParserHOOK, Cobol85PreprocessorParserIN, Cobol85PreprocessorParserINTDATE, Cobol85PreprocessorParserJA, Cobol85PreprocessorParserJP, Cobol85PreprocessorParserKA, Cobol85PreprocessorParserLANG, Cobol85PreprocessorParserLANGUAGE, Cobol85PreprocessorParserLC, Cobol85PreprocessorParserLENGTH, Cobol85PreprocessorParserLIB, Cobol85PreprocessorParserLILIAN, Cobol85PreprocessorParserLIN, Cobol85PreprocessorParserLINECOUNT, Cobol85PreprocessorParserLINKAGE, Cobol85PreprocessorParserLIST, Cobol85PreprocessorParserLM, Cobol85PreprocessorParserLONGMIXED, Cobol85PreprocessorParserLONGUPPER, Cobol85PreprocessorParserLU, Cobol85PreprocessorParserMAP, Cobol85PreprocessorParserMARGINS, Cobol85PreprocessorParserMAX, Cobol85PreprocessorParserMD, Cobol85PreprocessorParserMDECK, Cobol85PreprocessorParserMIG, Cobol85PreprocessorParserMIXED, Cobol85PreprocessorParserNAME, Cobol85PreprocessorParserNAT, Cobol85PreprocessorParserNATIONAL, Cobol85PreprocessorParserNATLANG, Cobol85PreprocessorParserNN, Cobol85PreprocessorParserNO, Cobol85PreprocessorParserNOADATA, Cobol85PreprocessorParserNOADV, Cobol85PreprocessorParserNOALIAS, Cobol85PreprocessorParserNOAWO, Cobol85PreprocessorParserNOBLOCK0, Cobol85PreprocessorParserNOC, Cobol85PreprocessorParserNOCBLCARD, Cobol85PreprocessorParserNOCICS, Cobol85PreprocessorParserNOCMPR2, Cobol85PreprocessorParserNOCOMPILE, Cobol85PreprocessorParserNOCPSM, Cobol85PreprocessorParserNOCURR, Cobol85PreprocessorParserNOCURRENCY, Cobol85PreprocessorParserNOD, Cobol85PreprocessorParserNODATEPROC, Cobol85PreprocessorParserNODBCS, Cobol85PreprocessorParserNODE, Cobol85PreprocessorParserNODEBUG, Cobol85PreprocessorParserNODECK, Cobol85PreprocessorParserNODIAGTRUNC, Cobol85PreprocessorParserNODLL, Cobol85PreprocessorParserNODU, Cobol85PreprocessorParserNODUMP, Cobol85PreprocessorParserNODP, Cobol85PreprocessorParserNODTR, Cobol85PreprocessorParserNODYN, Cobol85PreprocessorParserNODYNAM, Cobol85PreprocessorParserNOEDF, Cobol85PreprocessorParserNOEJPD, Cobol85PreprocessorParserNOEPILOG, Cobol85PreprocessorParserNOEXIT, Cobol85PreprocessorParserNOEXP, Cobol85PreprocessorParserNOEXPORTALL, Cobol85PreprocessorParserNOF, Cobol85PreprocessorParserNOFASTSRT, Cobol85PreprocessorParserNOFEPI, Cobol85PreprocessorParserNOFLAG, Cobol85PreprocessorParserNOFLAGMIG, Cobol85PreprocessorParserNOFLAGSTD, Cobol85PreprocessorParserNOFSRT, Cobol85PreprocessorParserNOGRAPHIC, Cobol85PreprocessorParserNOHOOK, Cobol85PreprocessorParserNOLENGTH, Cobol85PreprocessorParserNOLIB, Cobol85PreprocessorParserNOLINKAGE, Cobol85PreprocessorParserNOLIST, Cobol85PreprocessorParserNOMAP, Cobol85PreprocessorParserNOMD, Cobol85PreprocessorParserNOMDECK, Cobol85PreprocessorParserNONAME, Cobol85PreprocessorParserNONUM, Cobol85PreprocessorParserNONUMBER, Cobol85PreprocessorParserNOOBJ, Cobol85PreprocessorParserNOOBJECT, Cobol85PreprocessorParserNOOFF, Cobol85PreprocessorParserNOOFFSET, Cobol85PreprocessorParserNOOPSEQUENCE, Cobol85PreprocessorParserNOOPT, Cobol85PreprocessorParserNOOPTIMIZE, Cobol85PreprocessorParserNOOPTIONS, Cobol85PreprocessorParserNOP, Cobol85PreprocessorParserNOPFD, Cobol85PreprocessorParserNOPROLOG, Cobol85PreprocessorParserNORENT, Cobol85PreprocessorParserNOS, Cobol85PreprocessorParserNOSEP, Cobol85PreprocessorParserNOSEPARATE, Cobol85PreprocessorParserNOSEQ, Cobol85PreprocessorParserNOSOURCE, Cobol85PreprocessorParserNOSPIE, Cobol85PreprocessorParserNOSQL, Cobol85PreprocessorParserNOSQLC, Cobol85PreprocessorParserNOSQLCCSID, Cobol85PreprocessorParserNOSSR, Cobol85PreprocessorParserNOSSRANGE, Cobol85PreprocessorParserNOSTDTRUNC, Cobol85PreprocessorParserNOSEQUENCE, Cobol85PreprocessorParserNOTERM, Cobol85PreprocessorParserNOTERMINAL, Cobol85PreprocessorParserNOTEST, Cobol85PreprocessorParserNOTHREAD, Cobol85PreprocessorParserNOTRIG, Cobol85PreprocessorParserNOVBREF, Cobol85PreprocessorParserNOWORD, Cobol85PreprocessorParserNOX, Cobol85PreprocessorParserNOXREF, Cobol85PreprocessorParserNOZWB, Cobol85PreprocessorParserNS, Cobol85PreprocessorParserNSEQ, Cobol85PreprocessorParserNSYMBOL, Cobol85PreprocessorParserNUM, Cobol85PreprocessorParserNUMBER, Cobol85PreprocessorParserNUMPROC, Cobol85PreprocessorParserOBJ, Cobol85PreprocessorParserOBJECT, Cobol85PreprocessorParserOF, Cobol85PreprocessorParserOFF, Cobol85PreprocessorParserOFFSET, Cobol85PreprocessorParserON, Cobol85PreprocessorParserOP, Cobol85PreprocessorParserOPMARGINS, Cobol85PreprocessorParserOPSEQUENCE, Cobol85PreprocessorParserOPT, Cobol85PreprocessorParserOPTFILE, Cobol85PreprocessorParserOPTIMIZE, Cobol85PreprocessorParserOPTIONS, Cobol85PreprocessorParserOUT, Cobol85PreprocessorParserOUTDD, Cobol85PreprocessorParserPFD, Cobol85PreprocessorParserPPTDBG, Cobol85PreprocessorParserPGMN, Cobol85PreprocessorParserPGMNAME, Cobol85PreprocessorParserPROCESS, Cobol85PreprocessorParserPROLOG, Cobol85PreprocessorParserQUOTE, Cobol85PreprocessorParserRENT, Cobol85PreprocessorParserREPLACING, Cobol85PreprocessorParserRMODE, Cobol85PreprocessorParserSEP, Cobol85PreprocessorParserSEPARATE, Cobol85PreprocessorParserSEQ, Cobol85PreprocessorParserSEQUENCE, Cobol85PreprocessorParserSHORT, Cobol85PreprocessorParserSIZE, Cobol85PreprocessorParserSOURCE, Cobol85PreprocessorParserSP, Cobol85PreprocessorParserSPACE, Cobol85PreprocessorParserSPIE, Cobol85PreprocessorParserSQL, Cobol85PreprocessorParserSQLC, Cobol85PreprocessorParserSQLCCSID, Cobol85PreprocessorParserSS, Cobol85PreprocessorParserSSR, Cobol85PreprocessorParserSSRANGE, Cobol85PreprocessorParserSTD, Cobol85PreprocessorParserSYSEIB, Cobol85PreprocessorParserSZ, Cobol85PreprocessorParserTERM, Cobol85PreprocessorParserTERMINAL, Cobol85PreprocessorParserTEST, Cobol85PreprocessorParserTHREAD, Cobol85PreprocessorParserTITLE, Cobol85PreprocessorParserTRIG, Cobol85PreprocessorParserTRUNC, Cobol85PreprocessorParserUE, Cobol85PreprocessorParserUPPER, Cobol85PreprocessorParserVBREF, Cobol85PreprocessorParserWD, Cobol85PreprocessorParserXMLPARSE, Cobol85PreprocessorParserXMLSS, Cobol85PreprocessorParserXOPTS, Cobol85PreprocessorParserXREF, Cobol85PreprocessorParserYEARWINDOW, Cobol85PreprocessorParserYW, Cobol85PreprocessorParserZWB, Cobol85PreprocessorParserC_CHAR, Cobol85PreprocessorParserD_CHAR, Cobol85PreprocessorParserE_CHAR, Cobol85PreprocessorParserF_CHAR, Cobol85PreprocessorParserH_CHAR, Cobol85PreprocessorParserI_CHAR, Cobol85PreprocessorParserM_CHAR, Cobol85PreprocessorParserN_CHAR, Cobol85PreprocessorParserQ_CHAR, Cobol85PreprocessorParserS_CHAR, Cobol85PreprocessorParserU_CHAR, Cobol85PreprocessorParserW_CHAR, Cobol85PreprocessorParserX_CHAR, Cobol85PreprocessorParserCOMMACHAR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(668)
			p.CharDataKeyword()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLiteralContext() *LiteralContext {
	var p = new(LiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_literal
	return p
}

func (*LiteralContext) IsLiteralContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_literal

	return p
}

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

func (s *LiteralContext) NONNUMERICLITERAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONNUMERICLITERAL, 0)
}

func (s *LiteralContext) NUMERICLITERAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUMERICLITERAL, 0)
}

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

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

func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterLiteral(s)
	}
}

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitLiteral(s)
	}
}

func (p *Cobol85PreprocessorParser) Literal() (localctx ILiteralContext) {
	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, Cobol85PreprocessorParserRULE_literal)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(671)
		_la = p.GetTokenStream().LA(1)

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

	return localctx
}

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

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

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

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

func NewEmptyFilenameContext() *FilenameContext {
	var p = new(FilenameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_filename
	return p
}

func (*FilenameContext) IsFilenameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_filename

	return p
}

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

func (s *FilenameContext) FILENAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFILENAME, 0)
}

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

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

func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterFilename(s)
	}
}

func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitFilename(s)
	}
}

func (p *Cobol85PreprocessorParser) Filename() (localctx IFilenameContext) {
	localctx = NewFilenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, Cobol85PreprocessorParserRULE_filename)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(673)
		p.Match(Cobol85PreprocessorParserFILENAME)
	}

	return localctx
}

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

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

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

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

func NewEmptyCharDataKeywordContext() *CharDataKeywordContext {
	var p = new(CharDataKeywordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataKeyword
	return p
}

func (*CharDataKeywordContext) IsCharDataKeywordContext() {}

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

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

	p.parser = parser
	p.RuleIndex = Cobol85PreprocessorParserRULE_charDataKeyword

	return p
}

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

func (s *CharDataKeywordContext) ADATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserADATA, 0)
}

func (s *CharDataKeywordContext) ADV() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserADV, 0)
}

func (s *CharDataKeywordContext) ALIAS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserALIAS, 0)
}

func (s *CharDataKeywordContext) ANSI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserANSI, 0)
}

func (s *CharDataKeywordContext) ANY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserANY, 0)
}

func (s *CharDataKeywordContext) APOST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAPOST, 0)
}

func (s *CharDataKeywordContext) AR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAR, 0)
}

func (s *CharDataKeywordContext) ARITH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserARITH, 0)
}

func (s *CharDataKeywordContext) AUTO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAUTO, 0)
}

func (s *CharDataKeywordContext) AWO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserAWO, 0)
}

func (s *CharDataKeywordContext) BIN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBIN, 0)
}

func (s *CharDataKeywordContext) BLOCK0() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBLOCK0, 0)
}

func (s *CharDataKeywordContext) BUF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBUF, 0)
}

func (s *CharDataKeywordContext) BUFSIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBUFSIZE, 0)
}

func (s *CharDataKeywordContext) BY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserBY, 0)
}

func (s *CharDataKeywordContext) CBL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCBL, 0)
}

func (s *CharDataKeywordContext) CBLCARD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCBLCARD, 0)
}

func (s *CharDataKeywordContext) CO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCO, 0)
}

func (s *CharDataKeywordContext) COBOL2() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOBOL2, 0)
}

func (s *CharDataKeywordContext) COBOL3() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOBOL3, 0)
}

func (s *CharDataKeywordContext) CODEPAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCODEPAGE, 0)
}

func (s *CharDataKeywordContext) COMMACHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMMACHAR, 0)
}

func (s *CharDataKeywordContext) COMPAT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMPAT, 0)
}

func (s *CharDataKeywordContext) COMPILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCOMPILE, 0)
}

func (s *CharDataKeywordContext) CP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCP, 0)
}

func (s *CharDataKeywordContext) CPP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCPP, 0)
}

func (s *CharDataKeywordContext) CPSM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCPSM, 0)
}

func (s *CharDataKeywordContext) CS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCS, 0)
}

func (s *CharDataKeywordContext) CURR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCURR, 0)
}

func (s *CharDataKeywordContext) CURRENCY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserCURRENCY, 0)
}

func (s *CharDataKeywordContext) DATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDATA, 0)
}

func (s *CharDataKeywordContext) DATEPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDATEPROC, 0)
}

func (s *CharDataKeywordContext) DBCS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDBCS, 0)
}

func (s *CharDataKeywordContext) DD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDD, 0)
}

func (s *CharDataKeywordContext) DEBUG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDEBUG, 0)
}

func (s *CharDataKeywordContext) DECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDECK, 0)
}

func (s *CharDataKeywordContext) DIAGTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDIAGTRUNC, 0)
}

func (s *CharDataKeywordContext) DLI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDLI, 0)
}

func (s *CharDataKeywordContext) DLL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDLL, 0)
}

func (s *CharDataKeywordContext) DP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDP, 0)
}

func (s *CharDataKeywordContext) DTR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDTR, 0)
}

func (s *CharDataKeywordContext) DU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDU, 0)
}

func (s *CharDataKeywordContext) DUMP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDUMP, 0)
}

func (s *CharDataKeywordContext) DYN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDYN, 0)
}

func (s *CharDataKeywordContext) DYNAM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserDYNAM, 0)
}

func (s *CharDataKeywordContext) EDF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEDF, 0)
}

func (s *CharDataKeywordContext) EJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEJECT, 0)
}

func (s *CharDataKeywordContext) EJPD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEJPD, 0)
}

func (s *CharDataKeywordContext) EN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEN, 0)
}

func (s *CharDataKeywordContext) ENGLISH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserENGLISH, 0)
}

func (s *CharDataKeywordContext) EPILOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEPILOG, 0)
}

func (s *CharDataKeywordContext) EXCI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXCI, 0)
}

func (s *CharDataKeywordContext) EXIT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXIT, 0)
}

func (s *CharDataKeywordContext) EXP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXP, 0)
}

func (s *CharDataKeywordContext) EXPORTALL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXPORTALL, 0)
}

func (s *CharDataKeywordContext) EXTEND() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserEXTEND, 0)
}

func (s *CharDataKeywordContext) FASTSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFASTSRT, 0)
}

func (s *CharDataKeywordContext) FLAG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFLAG, 0)
}

func (s *CharDataKeywordContext) FLAGSTD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFLAGSTD, 0)
}

func (s *CharDataKeywordContext) FULL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFULL, 0)
}

func (s *CharDataKeywordContext) FSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserFSRT, 0)
}

func (s *CharDataKeywordContext) GDS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserGDS, 0)
}

func (s *CharDataKeywordContext) GRAPHIC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserGRAPHIC, 0)
}

func (s *CharDataKeywordContext) HOOK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserHOOK, 0)
}

func (s *CharDataKeywordContext) IN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserIN, 0)
}

func (s *CharDataKeywordContext) INTDATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserINTDATE, 0)
}

func (s *CharDataKeywordContext) JA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserJA, 0)
}

func (s *CharDataKeywordContext) JP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserJP, 0)
}

func (s *CharDataKeywordContext) KA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserKA, 0)
}

func (s *CharDataKeywordContext) LANG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLANG, 0)
}

func (s *CharDataKeywordContext) LANGUAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLANGUAGE, 0)
}

func (s *CharDataKeywordContext) LC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLC, 0)
}

func (s *CharDataKeywordContext) LENGTH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLENGTH, 0)
}

func (s *CharDataKeywordContext) LIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIB, 0)
}

func (s *CharDataKeywordContext) LILIAN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLILIAN, 0)
}

func (s *CharDataKeywordContext) LIN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIN, 0)
}

func (s *CharDataKeywordContext) LINECOUNT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLINECOUNT, 0)
}

func (s *CharDataKeywordContext) LINKAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLINKAGE, 0)
}

func (s *CharDataKeywordContext) LIST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLIST, 0)
}

func (s *CharDataKeywordContext) LM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLM, 0)
}

func (s *CharDataKeywordContext) LONGMIXED() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLONGMIXED, 0)
}

func (s *CharDataKeywordContext) LONGUPPER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLONGUPPER, 0)
}

func (s *CharDataKeywordContext) LU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserLU, 0)
}

func (s *CharDataKeywordContext) MAP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMAP, 0)
}

func (s *CharDataKeywordContext) MARGINS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMARGINS, 0)
}

func (s *CharDataKeywordContext) MAX() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMAX, 0)
}

func (s *CharDataKeywordContext) MD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMD, 0)
}

func (s *CharDataKeywordContext) MDECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMDECK, 0)
}

func (s *CharDataKeywordContext) MIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMIG, 0)
}

func (s *CharDataKeywordContext) MIXED() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserMIXED, 0)
}

func (s *CharDataKeywordContext) NAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNAME, 0)
}

func (s *CharDataKeywordContext) NAT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNAT, 0)
}

func (s *CharDataKeywordContext) NATIONAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNATIONAL, 0)
}

func (s *CharDataKeywordContext) NATLANG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNATLANG, 0)
}

func (s *CharDataKeywordContext) NN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNN, 0)
}

func (s *CharDataKeywordContext) NO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNO, 0)
}

func (s *CharDataKeywordContext) NOADATA() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOADATA, 0)
}

func (s *CharDataKeywordContext) NOADV() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOADV, 0)
}

func (s *CharDataKeywordContext) NOALIAS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOALIAS, 0)
}

func (s *CharDataKeywordContext) NOAWO() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOAWO, 0)
}

func (s *CharDataKeywordContext) NOBLOCK0() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOBLOCK0, 0)
}

func (s *CharDataKeywordContext) NOC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOC, 0)
}

func (s *CharDataKeywordContext) NOCBLCARD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCBLCARD, 0)
}

func (s *CharDataKeywordContext) NOCICS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCICS, 0)
}

func (s *CharDataKeywordContext) NOCMPR2() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCMPR2, 0)
}

func (s *CharDataKeywordContext) NOCOMPILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCOMPILE, 0)
}

func (s *CharDataKeywordContext) NOCPSM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCPSM, 0)
}

func (s *CharDataKeywordContext) NOCURR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCURR, 0)
}

func (s *CharDataKeywordContext) NOCURRENCY() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOCURRENCY, 0)
}

func (s *CharDataKeywordContext) NOD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOD, 0)
}

func (s *CharDataKeywordContext) NODATEPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODATEPROC, 0)
}

func (s *CharDataKeywordContext) NODBCS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODBCS, 0)
}

func (s *CharDataKeywordContext) NODE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODE, 0)
}

func (s *CharDataKeywordContext) NODEBUG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODEBUG, 0)
}

func (s *CharDataKeywordContext) NODECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODECK, 0)
}

func (s *CharDataKeywordContext) NODIAGTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODIAGTRUNC, 0)
}

func (s *CharDataKeywordContext) NODLL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODLL, 0)
}

func (s *CharDataKeywordContext) NODU() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODU, 0)
}

func (s *CharDataKeywordContext) NODUMP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODUMP, 0)
}

func (s *CharDataKeywordContext) NODP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODP, 0)
}

func (s *CharDataKeywordContext) NODTR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODTR, 0)
}

func (s *CharDataKeywordContext) NODYN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODYN, 0)
}

func (s *CharDataKeywordContext) NODYNAM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNODYNAM, 0)
}

func (s *CharDataKeywordContext) NOEDF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEDF, 0)
}

func (s *CharDataKeywordContext) NOEJPD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEJPD, 0)
}

func (s *CharDataKeywordContext) NOEPILOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEPILOG, 0)
}

func (s *CharDataKeywordContext) NOEXIT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXIT, 0)
}

func (s *CharDataKeywordContext) NOEXP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXP, 0)
}

func (s *CharDataKeywordContext) NOEXPORTALL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOEXPORTALL, 0)
}

func (s *CharDataKeywordContext) NOF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOF, 0)
}

func (s *CharDataKeywordContext) NOFASTSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFASTSRT, 0)
}

func (s *CharDataKeywordContext) NOFEPI() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFEPI, 0)
}

func (s *CharDataKeywordContext) NOFLAG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAG, 0)
}

func (s *CharDataKeywordContext) NOFLAGMIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAGMIG, 0)
}

func (s *CharDataKeywordContext) NOFLAGSTD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFLAGSTD, 0)
}

func (s *CharDataKeywordContext) NOFSRT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOFSRT, 0)
}

func (s *CharDataKeywordContext) NOGRAPHIC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOGRAPHIC, 0)
}

func (s *CharDataKeywordContext) NOHOOK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOHOOK, 0)
}

func (s *CharDataKeywordContext) NOLENGTH() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLENGTH, 0)
}

func (s *CharDataKeywordContext) NOLIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLIB, 0)
}

func (s *CharDataKeywordContext) NOLINKAGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLINKAGE, 0)
}

func (s *CharDataKeywordContext) NOLIST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOLIST, 0)
}

func (s *CharDataKeywordContext) NOMAP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMAP, 0)
}

func (s *CharDataKeywordContext) NOMD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMD, 0)
}

func (s *CharDataKeywordContext) NOMDECK() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOMDECK, 0)
}

func (s *CharDataKeywordContext) NONAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONAME, 0)
}

func (s *CharDataKeywordContext) NONUM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONUM, 0)
}

func (s *CharDataKeywordContext) NONUMBER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNONUMBER, 0)
}

func (s *CharDataKeywordContext) NOOBJ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOBJ, 0)
}

func (s *CharDataKeywordContext) NOOBJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOBJECT, 0)
}

func (s *CharDataKeywordContext) NOOFF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOFF, 0)
}

func (s *CharDataKeywordContext) NOOFFSET() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOFFSET, 0)
}

func (s *CharDataKeywordContext) NOOPSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPSEQUENCE, 0)
}

func (s *CharDataKeywordContext) NOOPT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPT, 0)
}

func (s *CharDataKeywordContext) NOOPTIMIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPTIMIZE, 0)
}

func (s *CharDataKeywordContext) NOOPTIONS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOOPTIONS, 0)
}

func (s *CharDataKeywordContext) NOP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOP, 0)
}

func (s *CharDataKeywordContext) NOPFD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOPFD, 0)
}

func (s *CharDataKeywordContext) NOPROLOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOPROLOG, 0)
}

func (s *CharDataKeywordContext) NORENT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNORENT, 0)
}

func (s *CharDataKeywordContext) NOS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOS, 0)
}

func (s *CharDataKeywordContext) NOSEP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEP, 0)
}

func (s *CharDataKeywordContext) NOSEPARATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEPARATE, 0)
}

func (s *CharDataKeywordContext) NOSEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEQ, 0)
}

func (s *CharDataKeywordContext) NOSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSEQUENCE, 0)
}

func (s *CharDataKeywordContext) NOSOURCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSOURCE, 0)
}

func (s *CharDataKeywordContext) NOSPIE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSPIE, 0)
}

func (s *CharDataKeywordContext) NOSQL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQL, 0)
}

func (s *CharDataKeywordContext) NOSQLC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQLC, 0)
}

func (s *CharDataKeywordContext) NOSQLCCSID() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSQLCCSID, 0)
}

func (s *CharDataKeywordContext) NOSSR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSSR, 0)
}

func (s *CharDataKeywordContext) NOSSRANGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSSRANGE, 0)
}

func (s *CharDataKeywordContext) NOSTDTRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOSTDTRUNC, 0)
}

func (s *CharDataKeywordContext) NOTERM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTERM, 0)
}

func (s *CharDataKeywordContext) NOTERMINAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTERMINAL, 0)
}

func (s *CharDataKeywordContext) NOTEST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTEST, 0)
}

func (s *CharDataKeywordContext) NOTHREAD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTHREAD, 0)
}

func (s *CharDataKeywordContext) NOTRIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOTRIG, 0)
}

func (s *CharDataKeywordContext) NOVBREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOVBREF, 0)
}

func (s *CharDataKeywordContext) NOWORD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOWORD, 0)
}

func (s *CharDataKeywordContext) NOX() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOX, 0)
}

func (s *CharDataKeywordContext) NOXREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOXREF, 0)
}

func (s *CharDataKeywordContext) NOZWB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNOZWB, 0)
}

func (s *CharDataKeywordContext) NSEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNSEQ, 0)
}

func (s *CharDataKeywordContext) NSYMBOL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNSYMBOL, 0)
}

func (s *CharDataKeywordContext) NS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNS, 0)
}

func (s *CharDataKeywordContext) NUM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUM, 0)
}

func (s *CharDataKeywordContext) NUMBER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUMBER, 0)
}

func (s *CharDataKeywordContext) NUMPROC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserNUMPROC, 0)
}

func (s *CharDataKeywordContext) OBJ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOBJ, 0)
}

func (s *CharDataKeywordContext) OBJECT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOBJECT, 0)
}

func (s *CharDataKeywordContext) ON() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserON, 0)
}

func (s *CharDataKeywordContext) OF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOF, 0)
}

func (s *CharDataKeywordContext) OFF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOFF, 0)
}

func (s *CharDataKeywordContext) OFFSET() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOFFSET, 0)
}

func (s *CharDataKeywordContext) OPMARGINS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPMARGINS, 0)
}

func (s *CharDataKeywordContext) OPSEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPSEQUENCE, 0)
}

func (s *CharDataKeywordContext) OPTIMIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTIMIZE, 0)
}

func (s *CharDataKeywordContext) OP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOP, 0)
}

func (s *CharDataKeywordContext) OPT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPT, 0)
}

func (s *CharDataKeywordContext) OPTFILE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTFILE, 0)
}

func (s *CharDataKeywordContext) OPTIONS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOPTIONS, 0)
}

func (s *CharDataKeywordContext) OUT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOUT, 0)
}

func (s *CharDataKeywordContext) OUTDD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserOUTDD, 0)
}

func (s *CharDataKeywordContext) PFD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPFD, 0)
}

func (s *CharDataKeywordContext) PGMN() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPGMN, 0)
}

func (s *CharDataKeywordContext) PGMNAME() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPGMNAME, 0)
}

func (s *CharDataKeywordContext) PPTDBG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPPTDBG, 0)
}

func (s *CharDataKeywordContext) PROCESS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPROCESS, 0)
}

func (s *CharDataKeywordContext) PROLOG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserPROLOG, 0)
}

func (s *CharDataKeywordContext) QUOTE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserQUOTE, 0)
}

func (s *CharDataKeywordContext) RENT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRENT, 0)
}

func (s *CharDataKeywordContext) REPLACING() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserREPLACING, 0)
}

func (s *CharDataKeywordContext) RMODE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserRMODE, 0)
}

func (s *CharDataKeywordContext) SEQ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEQ, 0)
}

func (s *CharDataKeywordContext) SEQUENCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEQUENCE, 0)
}

func (s *CharDataKeywordContext) SEP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEP, 0)
}

func (s *CharDataKeywordContext) SEPARATE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSEPARATE, 0)
}

func (s *CharDataKeywordContext) SHORT() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSHORT, 0)
}

func (s *CharDataKeywordContext) SIZE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSIZE, 0)
}

func (s *CharDataKeywordContext) SOURCE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSOURCE, 0)
}

func (s *CharDataKeywordContext) SP() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSP, 0)
}

func (s *CharDataKeywordContext) SPACE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSPACE, 0)
}

func (s *CharDataKeywordContext) SPIE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSPIE, 0)
}

func (s *CharDataKeywordContext) SQL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQL, 0)
}

func (s *CharDataKeywordContext) SQLC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQLC, 0)
}

func (s *CharDataKeywordContext) SQLCCSID() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSQLCCSID, 0)
}

func (s *CharDataKeywordContext) SS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSS, 0)
}

func (s *CharDataKeywordContext) SSR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSSR, 0)
}

func (s *CharDataKeywordContext) SSRANGE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSSRANGE, 0)
}

func (s *CharDataKeywordContext) STD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSTD, 0)
}

func (s *CharDataKeywordContext) SYSEIB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSYSEIB, 0)
}

func (s *CharDataKeywordContext) SZ() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserSZ, 0)
}

func (s *CharDataKeywordContext) TERM() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTERM, 0)
}

func (s *CharDataKeywordContext) TERMINAL() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTERMINAL, 0)
}

func (s *CharDataKeywordContext) TEST() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTEST, 0)
}

func (s *CharDataKeywordContext) THREAD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTHREAD, 0)
}

func (s *CharDataKeywordContext) TITLE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTITLE, 0)
}

func (s *CharDataKeywordContext) TRIG() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTRIG, 0)
}

func (s *CharDataKeywordContext) TRUNC() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserTRUNC, 0)
}

func (s *CharDataKeywordContext) UE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserUE, 0)
}

func (s *CharDataKeywordContext) UPPER() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserUPPER, 0)
}

func (s *CharDataKeywordContext) VBREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserVBREF, 0)
}

func (s *CharDataKeywordContext) WD() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserWD, 0)
}

func (s *CharDataKeywordContext) XMLPARSE() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXMLPARSE, 0)
}

func (s *CharDataKeywordContext) XMLSS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXMLSS, 0)
}

func (s *CharDataKeywordContext) XOPTS() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXOPTS, 0)
}

func (s *CharDataKeywordContext) XREF() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserXREF, 0)
}

func (s *CharDataKeywordContext) YEARWINDOW() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserYEARWINDOW, 0)
}

func (s *CharDataKeywordContext) YW() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserYW, 0)
}

func (s *CharDataKeywordContext) ZWB() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserZWB, 0)
}

func (s *CharDataKeywordContext) C_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserC_CHAR, 0)
}

func (s *CharDataKeywordContext) D_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserD_CHAR, 0)
}

func (s *CharDataKeywordContext) E_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserE_CHAR, 0)
}

func (s *CharDataKeywordContext) F_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserF_CHAR, 0)
}

func (s *CharDataKeywordContext) H_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserH_CHAR, 0)
}

func (s *CharDataKeywordContext) I_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserI_CHAR, 0)
}

func (s *CharDataKeywordContext) M_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserM_CHAR, 0)
}

func (s *CharDataKeywordContext) N_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserN_CHAR, 0)
}

func (s *CharDataKeywordContext) Q_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserQ_CHAR, 0)
}

func (s *CharDataKeywordContext) S_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserS_CHAR, 0)
}

func (s *CharDataKeywordContext) U_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserU_CHAR, 0)
}

func (s *CharDataKeywordContext) W_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserW_CHAR, 0)
}

func (s *CharDataKeywordContext) X_CHAR() antlr.TerminalNode {
	return s.GetToken(Cobol85PreprocessorParserX_CHAR, 0)
}

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

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

func (s *CharDataKeywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.EnterCharDataKeyword(s)
	}
}

func (s *CharDataKeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Cobol85PreprocessorListener); ok {
		listenerT.ExitCharDataKeyword(s)
	}
}

func (p *Cobol85PreprocessorParser) CharDataKeyword() (localctx ICharDataKeywordContext) {
	localctx = NewCharDataKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, Cobol85PreprocessorParserRULE_charDataKeyword)
	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(675)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Cobol85PreprocessorParserADATA)|(1<<Cobol85PreprocessorParserADV)|(1<<Cobol85PreprocessorParserALIAS)|(1<<Cobol85PreprocessorParserANSI)|(1<<Cobol85PreprocessorParserANY)|(1<<Cobol85PreprocessorParserAPOST)|(1<<Cobol85PreprocessorParserAR)|(1<<Cobol85PreprocessorParserARITH)|(1<<Cobol85PreprocessorParserAUTO)|(1<<Cobol85PreprocessorParserAWO)|(1<<Cobol85PreprocessorParserBIN)|(1<<Cobol85PreprocessorParserBLOCK0)|(1<<Cobol85PreprocessorParserBUF)|(1<<Cobol85PreprocessorParserBUFSIZE)|(1<<Cobol85PreprocessorParserBY)|(1<<Cobol85PreprocessorParserCBL)|(1<<Cobol85PreprocessorParserCBLCARD)|(1<<Cobol85PreprocessorParserCO)|(1<<Cobol85PreprocessorParserCOBOL2)|(1<<Cobol85PreprocessorParserCOBOL3)|(1<<Cobol85PreprocessorParserCODEPAGE)|(1<<Cobol85PreprocessorParserCOMPAT)|(1<<Cobol85PreprocessorParserCOMPILE)|(1<<Cobol85PreprocessorParserCP)|(1<<Cobol85PreprocessorParserCPP)|(1<<Cobol85PreprocessorParserCPSM)|(1<<Cobol85PreprocessorParserCS)|(1<<Cobol85PreprocessorParserCURR)|(1<<Cobol85PreprocessorParserCURRENCY))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(Cobol85PreprocessorParserDATA-32))|(1<<(Cobol85PreprocessorParserDATEPROC-32))|(1<<(Cobol85PreprocessorParserDBCS-32))|(1<<(Cobol85PreprocessorParserDD-32))|(1<<(Cobol85PreprocessorParserDEBUG-32))|(1<<(Cobol85PreprocessorParserDECK-32))|(1<<(Cobol85PreprocessorParserDIAGTRUNC-32))|(1<<(Cobol85PreprocessorParserDLI-32))|(1<<(Cobol85PreprocessorParserDLL-32))|(1<<(Cobol85PreprocessorParserDP-32))|(1<<(Cobol85PreprocessorParserDTR-32))|(1<<(Cobol85PreprocessorParserDU-32))|(1<<(Cobol85PreprocessorParserDUMP-32))|(1<<(Cobol85PreprocessorParserDYN-32))|(1<<(Cobol85PreprocessorParserDYNAM-32))|(1<<(Cobol85PreprocessorParserEDF-32))|(1<<(Cobol85PreprocessorParserEJECT-32))|(1<<(Cobol85PreprocessorParserEJPD-32))|(1<<(Cobol85PreprocessorParserEN-32))|(1<<(Cobol85PreprocessorParserENGLISH-32))|(1<<(Cobol85PreprocessorParserEPILOG-32))|(1<<(Cobol85PreprocessorParserEXCI-32))|(1<<(Cobol85PreprocessorParserEXIT-32))|(1<<(Cobol85PreprocessorParserEXP-32))|(1<<(Cobol85PreprocessorParserEXPORTALL-32))|(1<<(Cobol85PreprocessorParserEXTEND-32))|(1<<(Cobol85PreprocessorParserFASTSRT-32))|(1<<(Cobol85PreprocessorParserFLAG-32))|(1<<(Cobol85PreprocessorParserFLAGSTD-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(Cobol85PreprocessorParserFSRT-64))|(1<<(Cobol85PreprocessorParserFULL-64))|(1<<(Cobol85PreprocessorParserGDS-64))|(1<<(Cobol85PreprocessorParserGRAPHIC-64))|(1<<(Cobol85PreprocessorParserHOOK-64))|(1<<(Cobol85PreprocessorParserIN-64))|(1<<(Cobol85PreprocessorParserINTDATE-64))|(1<<(Cobol85PreprocessorParserJA-64))|(1<<(Cobol85PreprocessorParserJP-64))|(1<<(Cobol85PreprocessorParserKA-64))|(1<<(Cobol85PreprocessorParserLANG-64))|(1<<(Cobol85PreprocessorParserLANGUAGE-64))|(1<<(Cobol85PreprocessorParserLC-64))|(1<<(Cobol85PreprocessorParserLENGTH-64))|(1<<(Cobol85PreprocessorParserLIB-64))|(1<<(Cobol85PreprocessorParserLILIAN-64))|(1<<(Cobol85PreprocessorParserLIN-64))|(1<<(Cobol85PreprocessorParserLINECOUNT-64))|(1<<(Cobol85PreprocessorParserLINKAGE-64))|(1<<(Cobol85PreprocessorParserLIST-64))|(1<<(Cobol85PreprocessorParserLM-64))|(1<<(Cobol85PreprocessorParserLONGMIXED-64))|(1<<(Cobol85PreprocessorParserLONGUPPER-64))|(1<<(Cobol85PreprocessorParserLU-64))|(1<<(Cobol85PreprocessorParserMAP-64))|(1<<(Cobol85PreprocessorParserMARGINS-64))|(1<<(Cobol85PreprocessorParserMAX-64))|(1<<(Cobol85PreprocessorParserMD-64))|(1<<(Cobol85PreprocessorParserMDECK-64))|(1<<(Cobol85PreprocessorParserMIG-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(Cobol85PreprocessorParserMIXED-96))|(1<<(Cobol85PreprocessorParserNAME-96))|(1<<(Cobol85PreprocessorParserNAT-96))|(1<<(Cobol85PreprocessorParserNATIONAL-96))|(1<<(Cobol85PreprocessorParserNATLANG-96))|(1<<(Cobol85PreprocessorParserNN-96))|(1<<(Cobol85PreprocessorParserNO-96))|(1<<(Cobol85PreprocessorParserNOADATA-96))|(1<<(Cobol85PreprocessorParserNOADV-96))|(1<<(Cobol85PreprocessorParserNOALIAS-96))|(1<<(Cobol85PreprocessorParserNOAWO-96))|(1<<(Cobol85PreprocessorParserNOBLOCK0-96))|(1<<(Cobol85PreprocessorParserNOC-96))|(1<<(Cobol85PreprocessorParserNOCBLCARD-96))|(1<<(Cobol85PreprocessorParserNOCICS-96))|(1<<(Cobol85PreprocessorParserNOCMPR2-96))|(1<<(Cobol85PreprocessorParserNOCOMPILE-96))|(1<<(Cobol85PreprocessorParserNOCPSM-96))|(1<<(Cobol85PreprocessorParserNOCURR-96))|(1<<(Cobol85PreprocessorParserNOCURRENCY-96))|(1<<(Cobol85PreprocessorParserNOD-96))|(1<<(Cobol85PreprocessorParserNODATEPROC-96))|(1<<(Cobol85PreprocessorParserNODBCS-96))|(1<<(Cobol85PreprocessorParserNODE-96))|(1<<(Cobol85PreprocessorParserNODEBUG-96))|(1<<(Cobol85PreprocessorParserNODECK-96))|(1<<(Cobol85PreprocessorParserNODIAGTRUNC-96))|(1<<(Cobol85PreprocessorParserNODLL-96))|(1<<(Cobol85PreprocessorParserNODU-96))|(1<<(Cobol85PreprocessorParserNODUMP-96))|(1<<(Cobol85PreprocessorParserNODP-96))|(1<<(Cobol85PreprocessorParserNODTR-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(Cobol85PreprocessorParserNODYN-128))|(1<<(Cobol85PreprocessorParserNODYNAM-128))|(1<<(Cobol85PreprocessorParserNOEDF-128))|(1<<(Cobol85PreprocessorParserNOEJPD-128))|(1<<(Cobol85PreprocessorParserNOEPILOG-128))|(1<<(Cobol85PreprocessorParserNOEXIT-128))|(1<<(Cobol85PreprocessorParserNOEXP-128))|(1<<(Cobol85PreprocessorParserNOEXPORTALL-128))|(1<<(Cobol85PreprocessorParserNOF-128))|(1<<(Cobol85PreprocessorParserNOFASTSRT-128))|(1<<(Cobol85PreprocessorParserNOFEPI-128))|(1<<(Cobol85PreprocessorParserNOFLAG-128))|(1<<(Cobol85PreprocessorParserNOFLAGMIG-128))|(1<<(Cobol85PreprocessorParserNOFLAGSTD-128))|(1<<(Cobol85PreprocessorParserNOFSRT-128))|(1<<(Cobol85PreprocessorParserNOGRAPHIC-128))|(1<<(Cobol85PreprocessorParserNOHOOK-128))|(1<<(Cobol85PreprocessorParserNOLENGTH-128))|(1<<(Cobol85PreprocessorParserNOLIB-128))|(1<<(Cobol85PreprocessorParserNOLINKAGE-128))|(1<<(Cobol85PreprocessorParserNOLIST-128))|(1<<(Cobol85PreprocessorParserNOMAP-128))|(1<<(Cobol85PreprocessorParserNOMD-128))|(1<<(Cobol85PreprocessorParserNOMDECK-128))|(1<<(Cobol85PreprocessorParserNONAME-128))|(1<<(Cobol85PreprocessorParserNONUM-128))|(1<<(Cobol85PreprocessorParserNONUMBER-128))|(1<<(Cobol85PreprocessorParserNOOBJ-128))|(1<<(Cobol85PreprocessorParserNOOBJECT-128))|(1<<(Cobol85PreprocessorParserNOOFF-128))|(1<<(Cobol85PreprocessorParserNOOFFSET-128))|(1<<(Cobol85PreprocessorParserNOOPSEQUENCE-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(Cobol85PreprocessorParserNOOPT-160))|(1<<(Cobol85PreprocessorParserNOOPTIMIZE-160))|(1<<(Cobol85PreprocessorParserNOOPTIONS-160))|(1<<(Cobol85PreprocessorParserNOP-160))|(1<<(Cobol85PreprocessorParserNOPFD-160))|(1<<(Cobol85PreprocessorParserNOPROLOG-160))|(1<<(Cobol85PreprocessorParserNORENT-160))|(1<<(Cobol85PreprocessorParserNOS-160))|(1<<(Cobol85PreprocessorParserNOSEP-160))|(1<<(Cobol85PreprocessorParserNOSEPARATE-160))|(1<<(Cobol85PreprocessorParserNOSEQ-160))|(1<<(Cobol85PreprocessorParserNOSOURCE-160))|(1<<(Cobol85PreprocessorParserNOSPIE-160))|(1<<(Cobol85PreprocessorParserNOSQL-160))|(1<<(Cobol85PreprocessorParserNOSQLC-160))|(1<<(Cobol85PreprocessorParserNOSQLCCSID-160))|(1<<(Cobol85PreprocessorParserNOSSR-160))|(1<<(Cobol85PreprocessorParserNOSSRANGE-160))|(1<<(Cobol85PreprocessorParserNOSTDTRUNC-160))|(1<<(Cobol85PreprocessorParserNOSEQUENCE-160))|(1<<(Cobol85PreprocessorParserNOTERM-160))|(1<<(Cobol85PreprocessorParserNOTERMINAL-160))|(1<<(Cobol85PreprocessorParserNOTEST-160))|(1<<(Cobol85PreprocessorParserNOTHREAD-160))|(1<<(Cobol85PreprocessorParserNOTRIG-160))|(1<<(Cobol85PreprocessorParserNOVBREF-160))|(1<<(Cobol85PreprocessorParserNOWORD-160))|(1<<(Cobol85PreprocessorParserNOX-160))|(1<<(Cobol85PreprocessorParserNOXREF-160))|(1<<(Cobol85PreprocessorParserNOZWB-160))|(1<<(Cobol85PreprocessorParserNS-160)))) != 0) || (((_la-192)&-(0x1f+1)) == 0 && ((1<<uint((_la-192)))&((1<<(Cobol85PreprocessorParserNSEQ-192))|(1<<(Cobol85PreprocessorParserNSYMBOL-192))|(1<<(Cobol85PreprocessorParserNUM-192))|(1<<(Cobol85PreprocessorParserNUMBER-192))|(1<<(Cobol85PreprocessorParserNUMPROC-192))|(1<<(Cobol85PreprocessorParserOBJ-192))|(1<<(Cobol85PreprocessorParserOBJECT-192))|(1<<(Cobol85PreprocessorParserOF-192))|(1<<(Cobol85PreprocessorParserOFF-192))|(1<<(Cobol85PreprocessorParserOFFSET-192))|(1<<(Cobol85PreprocessorParserON-192))|(1<<(Cobol85PreprocessorParserOP-192))|(1<<(Cobol85PreprocessorParserOPMARGINS-192))|(1<<(Cobol85PreprocessorParserOPSEQUENCE-192))|(1<<(Cobol85PreprocessorParserOPT-192))|(1<<(Cobol85PreprocessorParserOPTFILE-192))|(1<<(Cobol85PreprocessorParserOPTIMIZE-192))|(1<<(Cobol85PreprocessorParserOPTIONS-192))|(1<<(Cobol85PreprocessorParserOUT-192))|(1<<(Cobol85PreprocessorParserOUTDD-192))|(1<<(Cobol85PreprocessorParserPFD-192))|(1<<(Cobol85PreprocessorParserPPTDBG-192))|(1<<(Cobol85PreprocessorParserPGMN-192))|(1<<(Cobol85PreprocessorParserPGMNAME-192))|(1<<(Cobol85PreprocessorParserPROCESS-192))|(1<<(Cobol85PreprocessorParserPROLOG-192))|(1<<(Cobol85PreprocessorParserQUOTE-192))|(1<<(Cobol85PreprocessorParserRENT-192))|(1<<(Cobol85PreprocessorParserREPLACING-192))|(1<<(Cobol85PreprocessorParserRMODE-192)))) != 0) || (((_la-224)&-(0x1f+1)) == 0 && ((1<<uint((_la-224)))&((1<<(Cobol85PreprocessorParserSEP-224))|(1<<(Cobol85PreprocessorParserSEPARATE-224))|(1<<(Cobol85PreprocessorParserSEQ-224))|(1<<(Cobol85PreprocessorParserSEQUENCE-224))|(1<<(Cobol85PreprocessorParserSHORT-224))|(1<<(Cobol85PreprocessorParserSIZE-224))|(1<<(Cobol85PreprocessorParserSOURCE-224))|(1<<(Cobol85PreprocessorParserSP-224))|(1<<(Cobol85PreprocessorParserSPACE-224))|(1<<(Cobol85PreprocessorParserSPIE-224))|(1<<(Cobol85PreprocessorParserSQL-224))|(1<<(Cobol85PreprocessorParserSQLC-224))|(1<<(Cobol85PreprocessorParserSQLCCSID-224))|(1<<(Cobol85PreprocessorParserSS-224))|(1<<(Cobol85PreprocessorParserSSR-224))|(1<<(Cobol85PreprocessorParserSSRANGE-224))|(1<<(Cobol85PreprocessorParserSTD-224))|(1<<(Cobol85PreprocessorParserSYSEIB-224))|(1<<(Cobol85PreprocessorParserSZ-224))|(1<<(Cobol85PreprocessorParserTERM-224))|(1<<(Cobol85PreprocessorParserTERMINAL-224))|(1<<(Cobol85PreprocessorParserTEST-224))|(1<<(Cobol85PreprocessorParserTHREAD-224))|(1<<(Cobol85PreprocessorParserTITLE-224))|(1<<(Cobol85PreprocessorParserTRIG-224))|(1<<(Cobol85PreprocessorParserTRUNC-224))|(1<<(Cobol85PreprocessorParserUE-224)))) != 0) || (((_la-256)&-(0x1f+1)) == 0 && ((1<<uint((_la-256)))&((1<<(Cobol85PreprocessorParserUPPER-256))|(1<<(Cobol85PreprocessorParserVBREF-256))|(1<<(Cobol85PreprocessorParserWD-256))|(1<<(Cobol85PreprocessorParserXMLPARSE-256))|(1<<(Cobol85PreprocessorParserXMLSS-256))|(1<<(Cobol85PreprocessorParserXOPTS-256))|(1<<(Cobol85PreprocessorParserXREF-256))|(1<<(Cobol85PreprocessorParserYEARWINDOW-256))|(1<<(Cobol85PreprocessorParserYW-256))|(1<<(Cobol85PreprocessorParserZWB-256))|(1<<(Cobol85PreprocessorParserC_CHAR-256))|(1<<(Cobol85PreprocessorParserD_CHAR-256))|(1<<(Cobol85PreprocessorParserE_CHAR-256))|(1<<(Cobol85PreprocessorParserF_CHAR-256))|(1<<(Cobol85PreprocessorParserH_CHAR-256))|(1<<(Cobol85PreprocessorParserI_CHAR-256))|(1<<(Cobol85PreprocessorParserM_CHAR-256))|(1<<(Cobol85PreprocessorParserN_CHAR-256))|(1<<(Cobol85PreprocessorParserQ_CHAR-256))|(1<<(Cobol85PreprocessorParserS_CHAR-256))|(1<<(Cobol85PreprocessorParserU_CHAR-256))|(1<<(Cobol85PreprocessorParserW_CHAR-256))|(1<<(Cobol85PreprocessorParserX_CHAR-256))|(1<<(Cobol85PreprocessorParserCOMMACHAR-256)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}